UnityEditor.TreeAO.CalcSoftOcclusion C# (CSharp) Method

        public static void CalcSoftOcclusion(Mesh mesh)
        {
            GameObject obj2 = new GameObject("Test") {
                layer = 0x1d
            };
            obj2.AddComponent<MeshFilter>().mesh = mesh;
            obj2.AddComponent<MeshCollider>();
            if (directions == null)
            {
                InitializeDirections();
            }
            Vector4[] vectorArray = new Vector4[directions.Length];
            for (int i = 0; i < directions.Length; i++)
            {
                vectorArray[i] = new Vector4(GetWeight(1, directions[i]), GetWeight(2, directions[i]), GetWeight(3, directions[i]), GetWeight(0, directions[i]));
            }
            Vector3[] vertices = mesh.vertices;
            Vector4[] vectorArray3 = new Vector4[vertices.Length];
            float num2 = 0f;
            for (int j = 0; j < vertices.Length; j++)
            {
                Vector4 zero = Vector4.zero;
                Vector3 v = obj2.transform.TransformPoint(vertices[j]);
                for (int m = 0; m < directions.Length; m++)
                {
                    float p = CountIntersections(v, obj2.transform.TransformDirection(directions[m]), 3f);
                    p = Mathf.Pow(0.5f, p);
                    zero += (Vector4) (vectorArray[m] * p);
                }
                zero = (Vector4) (zero / ((float) directions.Length));
                num2 += zero.w;
                vectorArray3[j] = zero;
            }
            num2 /= (float) vertices.Length;
            for (int k = 0; k < vertices.Length; k++)
            {
                vectorArray3[k].w -= num2;
            }
            mesh.tangents = vectorArray3;
            Object.DestroyImmediate(obj2);
        }

        void OnPostprocessModel(GameObject root)
        {
            // Check if path contains "AO Tree"
            string lowerPath = assetPath.ToLower();

            if (lowerPath.IndexOf("ambient-occlusion") != -1)
            {
                var physicsScene = root.scene.GetPhysicsScene();

                Component[] filters = root.GetComponentsInChildren(typeof(MeshFilter));
                foreach (MeshFilter filter in filters)
                {
                    if (filter.sharedMesh != null)
                    {
                        Mesh mesh = filter.sharedMesh;

                        // Calculate AO
                        TreeAO.CalcSoftOcclusion(mesh, physicsScene);

                        // Calculate vertex colors for tree waving
                        Bounds    bounds   = mesh.bounds;
                        Color[]   colors   = mesh.colors;
                        Vector3[] vertices = mesh.vertices;
                        Vector4[] tangents = mesh.tangents;
                        if (colors.Length == 0)
                        {
                            colors = new Color[mesh.vertexCount];
                            for (int i = 0; i < colors.Length; i++)
                            {
                                colors[i] = Color.white;
                            }
                        }

                        float maxAO = 0.0F;
                        for (int i = 0; i < tangents.Length; i++)
                        {
                            maxAO = Mathf.Max(tangents[i].w, maxAO);
                        }

                        float largest = 0.0F;
                        for (int i = 0; i < colors.Length; i++)
                        {
                            Vector2 offset = new Vector2(vertices[i].x, vertices[i].z);
                            float   branch = offset.magnitude;
                            largest = Mathf.Max(branch, largest);
                        }
                        for (int i = 0; i < colors.Length; i++)
                        {
                            Vector2 offset = new Vector2(vertices[i].x, vertices[i].z);
                            float   branch = offset.magnitude / largest;

                            float height = (vertices[i].y - bounds.min.y) / bounds.size.y;
                            //                  colors[i].a = tangents[i].w * maxAO + height;
                            colors[i].a = (height * branch) * 0.6F + height * 0.5F;
                        }
                        mesh.colors = colors;
                    }
                }
            }
        }