com.warwlock.mtree 1.0.2

package/Runtime/AO/DensityAO.cs

@@ -0,0 +1,203 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System.Threading;
+
+namespace Mtree
+{
+    public static class DensityAO
+    {
+        private static void BakeAo(Color[] colors, Vector3[] verts, Vector3[] normals, int[] triangles, Matrix4x4 transform, float resolution, float distance,string TreeName)
+        {
+            float[] weights = new float[triangles.Length / 3];
+            float totalArea = 0f;
+            for (int i = 0; i < triangles.Length; i+=3)
+            {
+                weights[i/3] = GetTriangleArea(verts[triangles[i]], verts[triangles[i + 1]], verts[triangles[i + 2]]);
+                totalArea += weights[i / 3];
+            }
+            for (int i = 0; i < weights.Length; i++)
+                weights[i] /= totalArea;
+
+            List<Vector3> points = new List<Vector3>();
+            WeightedRandom randomGenerator = new WeightedRandom(weights);
+            int sampleCount = (int)(totalArea / (resolution * resolution));
+            System.Random random = new System.Random();
+            for (int i = 0; i < sampleCount; i++)
+            {
+                int triangleIndex = randomGenerator.GetRandomIndex(random);
+                Vector3 point = SamplePointInTriangle(verts[triangles[triangleIndex * 3]], verts[triangles[triangleIndex * 3 + 1]], verts[triangles[triangleIndex * 3 + 2]], random);
+                point = transform.MultiplyPoint3x4(point);
+                points.Add(point);
+            }
+            KDTree tree = new KDTree(points.ToArray(),transform.MultiplyPoint3x4(Vector3.zero),TreeName);
+
+            float[] AoValues = new float[verts.Length];
+
+            float max = 0;
+            for (int i = 0; i < verts.Length; i++)
+            {
+                Vector3 origin = transform.MultiplyPoint3x4(verts[i]);
+                List <Vector3> neighbours = tree.RadiusSearch(origin, distance);
+                float cost = 0f;
+                Vector3 normal = transform.MultiplyVector(normals[i]);
+                foreach (Vector3 point in neighbours)
+                {
+                    float dist = Vector3.Distance(point, origin);
+                    cost += Mathf.Clamp01(Vector3.Dot(normal, point - origin) / dist + .5f) * Mathf.Exp(-dist);
+                }
+                max = Mathf.Max(cost, max);
+                AoValues[i] = cost;
+            }
+
+            for (int i = 0; i < AoValues.Length; i++)
+                AoValues[i] /= max;
+
+            for (int i = 0; i < colors.Length; i++)
+            {
+                colors[i].a = Mathf.Pow(1 - AoValues[i], 5f);
+            }
+
+        }
+
+        public static float GetTriangleArea(Vector3 v1, Vector3 v2, Vector3 v3)
+        {
+            Vector3 AB = v2 - v1;
+            Vector3 AC = v3 - v1;
+            return Vector3.Cross(AB, AC).magnitude / 2f;
+        }
+
+        private static Vector3 SamplePointInTriangle(Vector3 v1, Vector3 v2, Vector3 v3, System.Random random)
+        {
+            float w1 = (float)random.NextDouble();
+            float w2 = (float)random.NextDouble();
+            return (1 - Mathf.Sqrt(w1)) * v1 + (Mathf.Sqrt(w1) * (1 - w2)) * v2 + (w2 * Mathf.Sqrt(w1)) * v3;
+        }
+
+        public static ThreadHandleEditor BakeAoAsync(MeshFilter meshFilter, GameObject ob, float resolution, float distance)
+        {
+            Mesh mesh = meshFilter.sharedMesh;
+            Color[] colors = mesh.colors;
+            Vector3[] verts = mesh.vertices;
+            Vector3[] normals = mesh.normals;
+            int[] triangles = mesh.triangles;
+            string name = ob.name;
+
+            if (meshFilter == null || ob == null)
+                return null;
+
+            Matrix4x4 transformMatrix = ob.transform.localToWorldMatrix;
+            ThreadHandleEditor handle = new ThreadHandleEditor(
+                null,
+                () => BakeAo(colors, verts, normals, triangles, transformMatrix, resolution, distance, name),
+                () => { mesh.colors = colors; if (meshFilter != null) meshFilter.sharedMesh = mesh; });
+            handle.Start();
+
+            return handle;
+        }
+
+        public static void BakeAo(MeshFilter meshFilter, GameObject ob, float resolution, float distance)
+        {
+            Mesh mesh = meshFilter.sharedMesh;
+            Color[] colors = mesh.colors;
+            Vector3[] verts = mesh.vertices;
+            Vector3[] normals = mesh.normals;
+            int[] triangles = mesh.triangles;
+            Matrix4x4 transformMatrix = ob.transform.localToWorldMatrix;
+            BakeAo(colors, verts, normals, triangles, transformMatrix, resolution, distance,ob.name);
+            mesh.colors = colors;
+            meshFilter.sharedMesh = mesh;
+        }
+    }
+
+    public class ThreadHandleEditor
+    {
+        private Thread thread;
+        private readonly System.Action OnStartCallback;
+        private readonly System.Action ThreadedFunction;
+        private readonly System.Action OnEndCallback;
+        private Coroutine coroutine;
+        private bool begun;
+        private bool waited;
+        bool ended;
+        private float time;
+        
+
+        public ThreadHandleEditor(System.Action onStartCallback, System.Action threadedFunction, System.Action onEndCallback)
+        {
+            OnStartCallback = onStartCallback;
+            ThreadedFunction = threadedFunction;
+            OnEndCallback = onEndCallback;
+        }
+
+        public void Start()
+        {
+        #if UNITY_EDITOR
+            waited = false;
+            begun = false;
+            ended = false;
+            time = Time.realtimeSinceStartup;
+            UnityEditor.EditorApplication.update += Run;
+        #endif
+        }
+
+        private void Run()
+        {
+        #if UNITY_EDITOR
+
+            if (Time.realtimeSinceStartup - time > 1f)
+            {
+                waited = true;
+            }
+
+            if (waited && !begun)
+            {
+                begun = true;
+                if (OnStartCallback != null)
+                    OnStartCallback.Invoke();
+
+                if (ThreadedFunction != null)
+                {
+                    thread = new Thread(new ThreadStart(ThreadedFunction));
+                    thread.Start();
+                }
+                time = Time.realtimeSinceStartup;
+            }
+
+            if (!ended && waited && begun && (thread == null || !thread.IsAlive))
+            {
+                OnEndCallback.Invoke();
+                ended = true;
+                UnityEditor.EditorApplication.update -= Run;
+            }
+        #endif
+        }
+
+        public void Abort()
+        {
+            if(thread != null)
+                thread.Abort();
+            #if UNITY_EDITOR
+            UnityEditor.EditorApplication.update -= Run;
+            #endif
+        }
+
+        private IEnumerator RunThread()
+        {
+            if (OnStartCallback != null)
+                OnStartCallback.Invoke();
+
+            if (ThreadedFunction != null)
+            {
+                thread = new Thread(new ThreadStart(ThreadedFunction));
+                thread.Start();
+            }
+
+            while (thread != null && thread.IsAlive)
+                yield return null;
+
+            if(OnEndCallback != null)
+                OnEndCallback.Invoke();
+        }
+    }
+}

package/Runtime/AO/DensityAO.cs.meta

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

package/Runtime/AO/KDTree.cs

@@ -0,0 +1,169 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Mtree
+{
+    using System.Collections;
+    using System.Collections.Generic;
+    using UnityEngine;
+
+
+    public class KDTreeNode
+    {
+        public Vector3 position;
+        public KDTreeNode left;
+        public KDTreeNode right;
+
+        public KDTreeNode(Vector3 position)
+        {
+            this.position = position;
+        }
+
+        public void FindClosestRec(Vector3 point, ref float currBestDist, ref Vector3 currBest, int axis)
+        {
+            float dist = (point - position).sqrMagnitude;
+            if (dist < currBestDist)
+            {
+                currBestDist = dist;
+                currBest = position;
+            }
+            float diff = point[axis] - position[axis];
+            bool leftFirst = diff <= 0;
+
+            axis = (axis + 1) % 3;
+            if (leftFirst)
+            {
+                if (left != null)
+                    left.FindClosestRec(point, ref currBestDist, ref currBest, axis);
+                if (diff * diff < currBestDist && right != null)
+                    right.FindClosestRec(point, ref currBestDist, ref currBest, axis);
+            }
+            else
+            {
+                if (right != null)
+                    right.FindClosestRec(point, ref currBestDist, ref currBest, axis);
+                if (diff * diff < currBestDist && left != null)
+                    left.FindClosestRec(point, ref currBestDist, ref currBest, axis);
+            }
+        }
+
+        public void RadiusSearchRec(Vector3 center, float radiusSquared, ref List<Vector3> neighbours, int axis)
+        {
+            float dist = Vector3.SqrMagnitude(center - position);
+            if (dist < radiusSquared)
+                neighbours.Add(position);
+            float diff = (position[axis] - center[axis]);
+            axis = (axis + 1) % 3;
+            bool searchLeft = diff * diff * Mathf.Sign(diff) > -radiusSquared / 4;
+            bool searchRight = diff * diff * Mathf.Sign(diff) < radiusSquared / 4;
+
+            if (searchLeft && left != null)
+                left.RadiusSearchRec(center, radiusSquared, ref neighbours, axis);
+            if (searchRight && right != null)
+                right.RadiusSearchRec(center, radiusSquared, ref neighbours, axis);
+        }
+
+
+        public void AddPoint(Vector3 point, int axis)
+        {
+            bool isLeft = position[axis] > point[axis];
+            KDTreeNode child = isLeft ? left : right;
+            axis = (axis + 1) % 3;
+            if (child == null)
+            {
+                child = new KDTreeNode(point);
+                if (isLeft) left = child;
+                else right = child;
+            }
+            else
+                child.AddPoint(point, axis);
+
+        }
+    }
+
+    public class KDTree
+    {
+        private KDTreeNode root;
+
+        public KDTree(Vector3[] points,Vector3 t,string TreeName)
+        {
+            if (points.Length == 0)
+            {
+                points = new Vector3[]{t};
+            }
+
+            root = new KDTreeNode(points[0]);
+            for (int i = 1; i < points.Length; i++)
+            {
+                AddPoint(points[i]);
+            }
+
+            //root = BuildFromPointsRec(points, 0, 0, points.Length);
+        }
+
+        public KDTree()
+        {
+            root = new KDTreeNode(Vector3.zero);
+        }
+
+        public void AddPoint(Vector3 point)
+        {
+            root.AddPoint(point, 0);
+        }
+
+        private KDTreeNode BuildFromPointsRec(Vector3[] points, int axis, int start, int end)
+        {
+            Debug.Log(start + " " + end);
+
+            if (start == end - 1)
+            {
+                Debug.Log(start);
+                return new KDTreeNode(points[start]);
+            }
+
+            //int medianIndex = SelectMedian(points, axis, start, end);
+            int medianIndex = Random.Range(start, end - 1);
+
+            KDTreeNode node = new KDTreeNode(points[medianIndex]);
+            axis = (axis + 1) % 3;
+            node.left = BuildFromPointsRec(points, axis, start, medianIndex);
+            node.right = BuildFromPointsRec(points, axis, medianIndex, end);
+
+            return node;
+        }
+
+        public Vector3 FindClosest(Vector3 point)
+        {
+            float currBestDist = Mathf.Infinity;
+            Vector3 bestPoint = root.position;
+            root.FindClosestRec(point, ref currBestDist, ref bestPoint, 0);
+            return bestPoint;
+        }
+
+        public List<Vector3> RadiusSearch(Vector3 center, float radius)
+        {
+            List<Vector3> neighbours = new List<Vector3>();
+            root.RadiusSearchRec(center, radius * radius, ref neighbours, 0);
+            return neighbours;
+        }
+
+        private int SelectMedian(Vector3[] points, int axis, int start, int end)
+        {
+            float[] values = new float[end - start];
+            for (int i = start; i < end; i++)
+            {
+                values[i - start] = points[i][axis];
+            }
+            int[] indices = new int[values.Length];
+            for (int i = 0; i < indices.Length; i++)
+            {
+                indices[i] = i;
+            }
+
+            System.Array.Sort(values, indices);
+            return indices[indices.Length / 2];
+        }
+    }
+
+}

package/Runtime/AO/KDTree.cs.meta

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

package/Runtime/AO/WeightedRandom.cs

@@ -0,0 +1,74 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace Mtree
+{
+    /// <summary>
+    /// Class that allows to randomly select an index with a weigthed probability
+    /// </summary>
+    public class WeightedRandom
+    {
+        private float[] probs;
+        private int[] alias;
+
+        public WeightedRandom(float[] weights)
+        {
+            PrepareWeights(weights);
+        }
+
+        private void PrepareWeights(float[] weights)
+        {
+            Queue<int> small = new Queue<int>();
+            Queue<int> large = new Queue<int>();
+            int n = weights.Length;
+
+            alias = new int[n];
+            probs = new float[n];
+
+            float[] scaledWeights = new float[n];
+
+            for (int i = 0; i < weights.Length; i++)
+            {
+                scaledWeights[i] = weights[i] * n;
+
+                if (scaledWeights[i] >= 1)
+                    large.Enqueue(i);
+                else
+                    small.Enqueue(i);
+            }
+
+            while (small.Count > 0 && large.Count > 0)
+            {
+                int l = small.Dequeue();
+                int g = large.Dequeue();
+                probs[l] = scaledWeights[l];
+                alias[l] = g;
+                scaledWeights[g] = scaledWeights[g] + scaledWeights[l] - 1;
+                if (scaledWeights[g] < 1)
+                    small.Enqueue(g);
+                else
+                    large.Enqueue(g);
+            }
+            while (large.Count > 0)
+            {
+                probs[large.Dequeue()] = 1;
+            }
+            while (small.Count > 0)
+            {
+                probs[small.Dequeue()] = 1;
+            }
+        }
+
+        public int GetRandomIndex(System.Random random)
+        {
+            int i = random.Next(0, probs.Length);
+            if (random.NextDouble() < probs[i])
+                return i;
+            else
+                return alias[i];
+        }
+
+    }
+}

package/Runtime/AO/WeightedRandom.cs.meta

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

package/Runtime/AO.meta

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

package/Runtime/Bezier/Bezier.cs

@@ -0,0 +1,69 @@
+using UnityEngine;
+public enum BezierControlPointMode {
+		Free,
+		Aligned,
+		Mirrored
+	}
+
+public static class Bezier {
+
+	public static Vector3 GetPoint (Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3, float t) {
+		t = Mathf.Clamp01(t);
+		float OneMinusT = 1f - t;
+		return
+			OneMinusT * OneMinusT * OneMinusT * p0 +
+			3f * OneMinusT * OneMinusT * t * p1 +
+			3f * OneMinusT * t * t * p2 +
+			t * t * t * p3;
+	}
+
+	public static Vector3 GetFirstDerivative (Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3, float t) {
+		t = Mathf.Clamp01(t);
+		float oneMinusT = 1f - t;
+		return
+			3f * oneMinusT * oneMinusT * (p1 - p0) +
+			6f * oneMinusT * t * (p2 - p1) +
+			3f * t * t * (p3 - p2);
+	}
+	public static float GetTotalLenght(Vector3[] points){
+		float length = 0;
+		for(int i = 0; i<points.Length-3;i += 3){
+			if(points.Length>=3) length += BezierSingleLength(new Vector3[]{points[i],points[i+1],points[i+2],points[i+3]});
+		}
+		return length;
+	}
+	public static float BezierSingleLength(Vector3[] p){
+		var p0 = p[0] - p[1];
+		var p1 = p[2] - p[1];
+		var p2 = new Vector3();
+		var p3 = p[3]-p[2];
+
+		var l0 = p0.magnitude;
+		var l1 = p1.magnitude;
+		var l3 = p3.magnitude;
+		if(l0 > 0) p0 /= l0;
+		if(l1 > 0) p1 /= l1;
+		if(l3 > 0) p3 /= l3;
+
+		p2 = -p1;
+		var a = Mathf.Abs(Vector3.Dot(p0,p1)) + Mathf.Abs(Vector3.Dot(p2,p3));
+		if(a > 1.98f || l0 + l1 + l3 < (4 - a)*8) return l0+l1+l3;
+
+		var bl = new Vector3[4];
+		var br = new Vector3[4];
+
+		bl[0] = p[0];
+		bl[1] = (p[0]+p[1]) 	* 0.5f;
+
+		var mid = (p[1]+p[2]) 	* 0.5f;
+
+		bl[2] = (bl[1]+mid) 	* 0.5f;
+		br[3] = p[3];
+		br[2] = (p[2]+p[3]) 	* 0.5f;
+		br[1] = (br[2]+mid)		* 0.5f;
+		br[0] = (br[1]+bl[2])	* 0.5f;
+		bl[3] = br[0];
+		
+		return BezierSingleLength(bl) + BezierSingleLength(br);
+	}
+}

package/Runtime/Bezier/Bezier.cs.meta

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