com.warwlock.mtree 1.0.2

package/Runtime/Bezier/MtreeBezier.cs

@@ -0,0 +1,185 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using Mtree;
+
+[RequireComponent(typeof(MtreeComponent))]
+public class MtreeBezier : MonoBehaviour {
+
+	[SerializeField]
+	public Vector3[] points;
+	
+	[SerializeField] 
+	public Vector3[] s_positions = new Vector3[0],s_directions = new Vector3[0];
+	
+	[SerializeField]
+	public bool MTreeDoBezier,MTreeLeafDirection;
+
+	[SerializeField]
+	private BezierControlPointMode[] modes;
+	
+	[SerializeField]
+	public Vector3 s_branchdirection;
+	public int ControlPointCount {
+		get {
+			return points.Length;
+		}
+		
+	}
+
+	public Vector3 GetControlPoint (int index) {
+		return points[index];
+	}
+
+	public void SetControlPoint (int index, Vector3 point) {
+		if (index % 3 == 0) {
+			Vector3 delta = point - points[index];
+				if (index > 0) {
+					points[index - 1] += delta;
+				}
+				if (index + 1 < points.Length) {
+					points[index + 1] += delta;
+				}
+			
+		}
+		points[index] = point;
+		EnforceMode(index);
+
+		if(points.Length > 3 && MTreeDoBezier){
+			s_positions = new Vector3[0];
+			s_directions = new Vector3[0];
+            //SetMtreeCalculations();
+#if UNITY_EDITOR
+
+            GetComponent<MtreeComponent>().GenerateTree();
+#endif
+        }
+
+	}
+
+	public BezierControlPointMode GetControlPointMode (int index) {
+		return modes[(index + 1) / 3];
+	}
+
+	public void SetControlPointMode (int index, BezierControlPointMode mode) {
+		int modeIndex = (index + 1) / 3;
+		modes[modeIndex] = mode;
+		if (modeIndex == modes.Length - 1) {
+				modes[0] = mode;
+			
+		}
+		EnforceMode(index);
+
+	}
+
+	private void EnforceMode (int index) {
+		int modeIndex = (index + 1) / 3;
+		BezierControlPointMode mode = modes[modeIndex];
+		if (mode == BezierControlPointMode.Free || (modeIndex == 0 || modeIndex == modes.Length - 1)) {
+			return;
+		}
+
+		int middleIndex = modeIndex * 3;
+		int fixedIndex, enforcedIndex;
+		if (index <= middleIndex) {
+			fixedIndex = middleIndex - 1;
+			if (fixedIndex < 0) {
+				fixedIndex = points.Length - 2;
+			}
+			enforcedIndex = middleIndex + 1;
+			if (enforcedIndex >= points.Length) {
+				enforcedIndex = 1;
+			}
+		}
+		else {
+			fixedIndex = middleIndex + 1;
+			if (fixedIndex >= points.Length) {
+				fixedIndex = 1;
+			}
+			enforcedIndex = middleIndex - 1;
+			if (enforcedIndex < 0) {
+				enforcedIndex = points.Length - 2;
+			}
+		}
+
+		Vector3 middle = points[middleIndex];
+		Vector3 enforcedTangent = middle - points[fixedIndex];
+		if (mode == BezierControlPointMode.Aligned) {
+			enforcedTangent = enforcedTangent.normalized * Vector3.Distance(middle, points[enforcedIndex]);
+		}
+		points[enforcedIndex] = middle + enforcedTangent;
+	}
+
+	public int CurveCount {
+		get {
+			return (points.Length - 1) / 3;
+		}
+	}
+
+	public Vector3 GetPoint (float t) {
+		int i;
+		if (t >= 1f) {
+			t = 1f;
+			i = points.Length - 4;
+		}
+		else {
+			t = Mathf.Clamp01(t) * CurveCount;
+			i = (int)t;
+			t -= i;
+			i *= 3;
+		}
+		return transform.TransformPoint(Bezier.GetPoint(points[i], points[i + 1], points[i + 2], points[i + 3], t));
+	}
+	
+	public Vector3 GetVelocity (float t) {
+		int i;
+		if (t >= 1f) {
+			t = 1f;
+			i = points.Length - 4;
+		}
+		else {
+			t = Mathf.Clamp01(t) * CurveCount;
+			i = (int)t;
+			t -= i;
+			i *= 3;
+		}
+		return transform.TransformPoint(Bezier.GetFirstDerivative(points[i], points[i + 1], points[i + 2], points[i + 3], t)) - transform.position;
+	}
+	
+	public Vector3 GetDirection (float t) {
+		return GetVelocity(t).normalized;
+	}
+
+	public void AddCurve () {
+		Vector3 point = points[points.Length - 1];
+		System.Array.Resize(ref points, points.Length + 3);
+		point.y += 1f;
+		points[points.Length - 3] = point;
+		point.y += 1f;
+		points[points.Length - 2] = point;
+		point.y += 1f;
+		points[points.Length - 1] = point;
+
+		System.Array.Resize(ref modes, modes.Length + 1);
+		modes[modes.Length - 1] = modes[modes.Length - 2];
+		EnforceMode(points.Length - 4);
+	}
+	
+	public float GetLength(){
+		return Bezier.GetTotalLenght(points);
+	}
+	public void Reset () {
+		points = new Vector3[] {
+			new Vector3(0f, 0f, 0f),new Vector3(0f, 2f, 0f),new Vector3(0f, 6f, 0f),new Vector3(0f, 8f, 0f)
+			
+		};
+		modes = new BezierControlPointMode[] {
+			BezierControlPointMode.Free,
+			BezierControlPointMode.Free
+		};
+		s_positions = new Vector3[0];
+		s_directions = new Vector3[0];
+	}
+}
+
+

package/Runtime/Bezier/MtreeBezier.cs.meta

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

package/Runtime/Bezier.meta

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

package/Runtime/ExampleSceneManager.cs

@@ -0,0 +1,165 @@
+
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Rendering;
+using Mtree;
+[ExecuteInEditMode]
+public class ExampleSceneManager : MonoBehaviour
+{
+    List<Material> BarkMaterials,LeafMaterials;
+    Material Floor;
+    GameObject Trees,PostProcessing;
+    bool Setup = true;
+    
+    void PostProcessActive()
+    {
+    #if UNITY_POST_PROCESSING_STACK_V2
+
+        #if UNITY_2019_3_OR_NEWER
+	        
+	    if( Utils.GetCurrentPipeline() == "legacy"){
+	        PostProcessing = Instantiate(Resources.Load("Mtree/Examples/Post Processing") as GameObject,this.transform);
+			PostProcessing.name = "Post Processing";
+			PostProcessing.layer = 8;
+	        var cam = GetComponentInChildren<Camera>().gameObject;
+	        cam.layer = 1;
+
+	        var PPlayer = cam.GetComponent<UnityEngine.Rendering.PostProcessing.PostProcessLayer>();
+            if(PPlayer == null)
+            cam.AddComponent<UnityEngine.Rendering.PostProcessing.PostProcessLayer>();
+
+	        PPlayer.antialiasingMode = UnityEngine.Rendering.PostProcessing.PostProcessLayer.Antialiasing.FastApproximateAntialiasing;
+	        PPlayer.volumeLayer = 2;
+	        PostProcessing.transform.SetParent(this.transform);
+	    }
+        #else
+        PostProcessing = Instantiate(Resources.Load("Mtree/Examples/Post Processing") as GameObject,this.transform);
+			PostProcessing.name = "Post Processing";
+			PostProcessing.layer = 8;
+	        var cam = GetComponentInChildren<Camera>().gameObject;
+	        cam.layer = 1;
+
+	        var PPlayer = cam.GetComponent<UnityEngine.Rendering.PostProcessing.PostProcessLayer>();
+            if(PPlayer == null)
+            cam.AddComponent<UnityEngine.Rendering.PostProcessing.PostProcessLayer>();
+
+            PPlayer.antialiasingMode = UnityEngine.Rendering.PostProcessing.PostProcessLayer.Antialiasing.FastApproximateAntialiasing;
+	        PPlayer.volumeLayer.value = 2;
+	        PostProcessing.transform.SetParent(this.transform);
+	    #endif
+	#endif
+    
+    }
+    void LegacySetup(){
+	#if UNITY_2019_1_OR_NEWER
+		var obj = Instantiate(Resources.Load("Mtree/Examples/2019_1 Legacy") as GameObject,this.transform);
+		obj.name = "Legacy 2019.1+";
+		Debug.Log("Legacy 2019.1+ Scene loaded!");
+	#else
+        var obj = Instantiate(Resources.Load("Mtree/Examples/2017_4 Legacy") as GameObject,this.transform);
+		obj.name = "Legacy 2017.4+"; 
+		Debug.Log("Legacy 2017.4+ was loaded!");
+	#endif
+    }
+    void LWRPSetup()
+    {
+    #if UNITY_2018_3_OR_NEWER
+        var obj = Instantiate(Resources.Load("Mtree/Examples/2018_4 LWRP") as GameObject,this.transform);
+		obj.name = "LWRP 2018.4+";
+		Debug.Log("LWRP 2018.4+ Scene loaded!");
+    #endif
+    }
+
+    void HDRPSetup()
+    {
+        
+    #if UNITY_2019_3_OR_NEWER
+        var obj = Instantiate(Resources.Load("Mtree/Examples/2019_3 HDRP") as GameObject,this.transform);
+		obj.name = "HDRP 2019.3+"; 
+		Debug.Log("HDRP 2019.3+ Scene loaded!");
+    #else
+        var obj = Instantiate(Resources.Load("Mtree/Examples/2018_4 HDRP") as GameObject,this.transform);
+		obj.name = "HDRP 2018.4+";
+		Debug.Log("HDRP 2018.4+ Scene loaded!");
+    #endif
+    }
+    void URPSetup()
+    {
+    #if UNITY_2019_3_OR_NEWER
+		Instantiate(Resources.Load("Mtree/Examples/2019_3 URP") as GameObject,this.transform);
+        Debug.Log("URP 2019.3+ Scene loaded!");
+    #endif       
+    }
+    void Start()
+    {
+        
+        if(Setup){
+            foreach(Transform t in this.transform)
+                DestroyImmediate(t.gameObject);
+            switch(Utils.GetCurrentPipeline())
+            {
+                case "legacy":
+                    LegacySetup();
+                break;
+
+                case "lwrp":
+                    LWRPSetup();
+                break;
+
+                case "hdrp":
+                    HDRPSetup();
+                break;
+
+                case "urp":
+                    URPSetup();
+                break;
+            }
+            PostProcessActive();
+            UpdateMaterials();
+            Setup = false;
+        }
+    }
+    void UpdateMaterials(){
+        
+        BarkMaterials = new List<Material>();
+        LeafMaterials = new List<Material>();
+        var renderers = GameObject.Find("Trees").GetComponentsInChildren<MeshRenderer>();
+        Floor = transform.GetComponent<MeshRenderer>().sharedMaterial;
+        foreach (var r in renderers){
+            foreach(var m in r.sharedMaterials){
+                if(m.shader.name.Contains("Leafs"))
+                    LeafMaterials.Add(m);
+                if(m.shader.name.Contains("Bark"))
+                    BarkMaterials.Add(m);
+            }
+        }
+
+        for(int i = 0; i<BarkMaterials.Count;i++)
+            BarkMaterials[i].shader = Utils.GetBarkShader();
+        for(int i = 0; i<LeafMaterials.Count;i++)
+            LeafMaterials[i].shader = Utils.GetLeafShader();
+
+        switch(Utils.GetCurrentPipeline())
+            {
+                case "legacy":
+                    Floor.shader = Shader.Find("Standard");
+                break;
+
+                case "lwrp":
+                    Floor.shader = Shader.Find("Lightweight Render Pipeline/Lit");
+                break;
+
+                case "hdrp":
+                    Floor.shader = Shader.Find("HDRP/Lit");
+                break;
+
+                case "urp":
+                    Floor.shader = Shader.Find("Universal Render Pipeline/Lit");
+                break;
+            }
+
+
+        
+    }
+}

package/Runtime/ExampleSceneManager.cs.meta

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

package/Runtime/LODValues.cs

@@ -0,0 +1,44 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace Mtree
+{
+
+    public class LODValues : ScriptableObject
+    {
+        public float radialResolution = 1f;
+        public float simplifyAngleThreshold = 0.01f;
+        public float simplifyRadiusThreshold = 0f;
+        public float simplifyLeafs = 0f;
+
+        public void Init(LODValues previousLOD = null)
+        {
+            if (previousLOD == null)
+                return;
+            this.radialResolution = previousLOD.radialResolution / 2.5f;
+            this.simplifyAngleThreshold = Mathf.Lerp(previousLOD.simplifyAngleThreshold, 40, .2f);
+            this.simplifyRadiusThreshold = Mathf.Lerp(previousLOD.simplifyRadiusThreshold, .15f, .2f);
+            this.simplifyLeafs = Mathf.Clamp(previousLOD.simplifyLeafs + .2f, 0, 1);
+        }
+
+#if UNITY_EDITOR
+        public void DrawProperties()
+        {
+            SerializedObject obj = new SerializedObject(this);
+
+            EditorGUILayout.BeginVertical(EditorStyles.helpBox);
+            Utils.BoundedFloatProperty(obj.FindProperty("radialResolution"), new GUIContent("Radial resolution"), 0.001f);
+            EditorGUILayout.Slider(obj.FindProperty("simplifyAngleThreshold"), 0, 90, new GUIContent("Angle threshold"));
+            EditorGUILayout.Slider(obj.FindProperty("simplifyRadiusThreshold"), 0, .9f, new GUIContent("Simplify radius"));
+            EditorGUILayout.Slider(obj.FindProperty("simplifyLeafs"), 0, .99f, new GUIContent("Simplify leaves"));
+
+            EditorGUILayout.EndVertical();
+            obj.ApplyModifiedProperties();
+        }
+#endif
+    }
+}

package/Runtime/LODValues.cs.meta

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

package/Runtime/LeafPoint.cs

@@ -0,0 +1,135 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Mtree
+{
+    public struct LeafPoint
+    {
+        public Vector3 position;
+        public Vector3 direction;
+        public float size;
+        public Mesh[] meshes;
+        public bool overrideNormals;
+        public float distanceFromOrigin;
+        private float length;
+        private int uLoops;
+        private float resolution;
+        public bool procedural;
+        private float gravityStrength;
+
+
+        public LeafPoint(Vector3 pos, Vector3 dir, float size, Mesh[] m, bool overrideNorm, float distanceFromOrigin, float length=1, int uLoops=2, float resolution=1, bool procedural=false, float gravityStrength=1)
+        {
+            position = pos;
+            direction = dir;
+            this.size = size;
+            meshes = m;
+            overrideNormals = overrideNorm;
+            this.distanceFromOrigin = distanceFromOrigin;
+            this.length = length;
+            this.uLoops = uLoops;
+            this.resolution = resolution;
+            this.procedural = procedural;
+            this.gravityStrength = gravityStrength;
+        }
+
+        public Mesh GetMesh(int lodLevel)
+        {
+            if (!procedural)
+            {
+                if (meshes != null && meshes.Length > 0)
+                    return meshes[Mathf.Min(lodLevel, meshes.Length-1)];
+                else
+                    return null;
+            }
+            else
+                return GrowLeaf(); 
+        }
+
+        private Mesh GrowLeaf()
+        {
+            Vector3[] profile = new Vector3[uLoops];
+            Vector2[] profileUvs = new Vector2[uLoops];
+            for (int i=0; i<uLoops; i++)
+            {
+                float t = (float)i / (uLoops - 1);
+                float x_pos = t - 0.5f;
+                float y_pos = - Mathf.Pow(t-0.5f, 2);
+                if (uLoops == 2)
+                    y_pos = 0;
+                profile[i] = new Vector3(x_pos*2, y_pos, 0);
+                profileUvs[i] = new Vector2(t, 0);
+            }
+
+            Queue<Vector3> verts = new Queue<Vector3>();
+            Quaternion rot = Quaternion.FromToRotation(Vector3.up, direction);
+            rot = Quaternion.LookRotation(direction);
+            foreach (Vector3 v in profile)
+                verts.Enqueue(rot * v*size + position);
+            Queue<Vector2> uvs = new Queue<Vector2>(profileUvs);
+            Queue<int> triangles = new Queue<int>();
+            Vector3 lastPos = position;
+            Vector3 lastDir = direction.normalized;
+            int vCount = Mathf.Max(1, (int)(length * resolution));
+            float stepLength = length / vCount;
+            for (int i=0; i < vCount; i++)
+            {
+                Vector3 newDir = Vector3.Normalize(lastDir + Vector3.down * gravityStrength / resolution);
+                Vector3 newPos = lastPos + lastDir * stepLength;
+                if (Vector3.Angle(lastDir, newDir) < 10 && i != vCount - 1 || newPos.y < 0)
+                {
+                    lastPos = newPos;
+                    lastDir = newDir;
+                    continue;
+                }
+                //newDir = lastDir;
+                //newPos = position;
+                rot = Quaternion.FromToRotation(Vector3.up, Vector3.Slerp(lastDir, newDir, .5f));
+                rot = Quaternion.LookRotation(lastDir, Vector3.up);
+                int n = verts.Count;
+                for (int j=0; j<uLoops; j++)
+                {
+                    Vector3 v = (rot * profile[j]*size) + newPos;
+                    verts.Enqueue(v);
+                    uvs.Enqueue(new Vector2((float)j / (uLoops - 1), (float)(i+1)/vCount));
+                    if (j < uLoops - 1)
+                    {
+                        Utils.AddTriangle(triangles, n-uLoops + j, n + j , n - uLoops + 1 + j);
+                        Utils.AddTriangle(triangles, n + j , n + j + 1, n - uLoops + j + 1);
+                    }
+                }
+                lastPos = newPos;
+                lastDir = newDir;
+            }
+
+            Mesh mesh = new Mesh();
+            mesh.vertices = verts.ToArray();
+            mesh.uv = uvs.ToArray();
+            mesh.triangles = triangles.ToArray();
+            mesh.RecalculateNormals();
+            return mesh;
+        }
+    }
+
+    public struct LeafCandidate
+    {
+        public Vector3 position;
+        public Vector3 direction;
+        public float size;
+        public float parentBranchLength;
+        public float distanceFromOrigin;
+        public bool isEnd;
+
+
+        public LeafCandidate(Vector3 pos, Vector3 dir, float size, float branchLength, float distanceFromOrigin, bool isEnd)
+        {
+            position = pos;
+            direction = dir;
+            this.size = size;
+            parentBranchLength = branchLength;
+            this.distanceFromOrigin = distanceFromOrigin; ;
+            this.isEnd = isEnd;
+        }
+    }
+}

package/Runtime/LeafPoint.cs.meta

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

package/Runtime/MTree.Runtime.asmdef

@@ -0,0 +1,3 @@
+{
+	"name": "MTree.Runtime"
+}

package/Runtime/MTree.Runtime.asmdef.meta

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