public static void InitializeDirections()
{
float num = (float)((1.0 + (double)Mathf.Sqrt(5f)) / 2.0);
TreeAO.directions = new Vector3[60];
TreeAO.directions[0] = new Vector3(0.0f, 1f, 3f * num);
TreeAO.directions[1] = new Vector3(0.0f, 1f, -3f * num);
TreeAO.directions[2] = new Vector3(0.0f, -1f, 3f * num);
TreeAO.directions[3] = new Vector3(0.0f, -1f, -3f * num);
TreeAO.directions[4] = new Vector3(1f, 3f * num, 0.0f);
TreeAO.directions[5] = new Vector3(1f, -3f * num, 0.0f);
TreeAO.directions[6] = new Vector3(-1f, 3f * num, 0.0f);
TreeAO.directions[7] = new Vector3(-1f, -3f * num, 0.0f);
TreeAO.directions[8] = new Vector3(3f * num, 0.0f, 1f);
TreeAO.directions[9] = new Vector3(3f * num, 0.0f, -1f);
TreeAO.directions[10] = new Vector3(-3f * num, 0.0f, 1f);
TreeAO.directions[11] = new Vector3(-3f * num, 0.0f, -1f);
int offset1 = 12;
int offset2 = TreeAO.PermuteCuboid(TreeAO.directions, offset1, 2f, (float)(1.0 + 2.0 * (double)num), num);
int offset3 = TreeAO.PermuteCuboid(TreeAO.directions, offset2, (float)(1.0 + 2.0 * (double)num), num, 2f);
int offset4 = TreeAO.PermuteCuboid(TreeAO.directions, offset3, num, 2f, (float)(1.0 + 2.0 * (double)num));
int offset5 = TreeAO.PermuteCuboid(TreeAO.directions, offset4, 1f, 2f + num, 2f * num);
int offset6 = TreeAO.PermuteCuboid(TreeAO.directions, offset5, 2f + num, 2f * num, 1f);
TreeAO.PermuteCuboid(TreeAO.directions, offset6, 2f * num, 1f, 2f + num);
for (int index = 0; index < TreeAO.directions.Length; ++index)
{
TreeAO.directions[index] = TreeAO.directions[index].normalized;
}
}
public static void InitializeDirections()
{
float num = (1f + Mathf.Sqrt(5f)) / 2f;
TreeAO.directions = new Vector3[60];
TreeAO.directions[0] = new Vector3(0f, 1f, 3f * num);
TreeAO.directions[1] = new Vector3(0f, 1f, -3f * num);
TreeAO.directions[2] = new Vector3(0f, -1f, 3f * num);
TreeAO.directions[3] = new Vector3(0f, -1f, -3f * num);
TreeAO.directions[4] = new Vector3(1f, 3f * num, 0f);
TreeAO.directions[5] = new Vector3(1f, -3f * num, 0f);
TreeAO.directions[6] = new Vector3(-1f, 3f * num, 0f);
TreeAO.directions[7] = new Vector3(-1f, -3f * num, 0f);
TreeAO.directions[8] = new Vector3(3f * num, 0f, 1f);
TreeAO.directions[9] = new Vector3(3f * num, 0f, -1f);
TreeAO.directions[10] = new Vector3(-3f * num, 0f, 1f);
TreeAO.directions[11] = new Vector3(-3f * num, 0f, -1f);
int offset = 12;
offset = TreeAO.PermuteCuboid(TreeAO.directions, offset, 2f, 1f + 2f * num, num);
offset = TreeAO.PermuteCuboid(TreeAO.directions, offset, 1f + 2f * num, num, 2f);
offset = TreeAO.PermuteCuboid(TreeAO.directions, offset, num, 2f, 1f + 2f * num);
offset = TreeAO.PermuteCuboid(TreeAO.directions, offset, 1f, 2f + num, 2f * num);
offset = TreeAO.PermuteCuboid(TreeAO.directions, offset, 2f + num, 2f * num, 1f);
offset = TreeAO.PermuteCuboid(TreeAO.directions, offset, 2f * num, 1f, 2f + num);
for (int i = 0; i < TreeAO.directions.Length; i++)
{
TreeAO.directions[i] = TreeAO.directions[i].normalized;
}
}
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;
}
}
}
}
private void OnPostprocessModel(GameObject root)
{
string text = base.assetPath.ToLower();
if (text.IndexOf("ambient-occlusion") != -1)
{
Component[] componentsInChildren = root.GetComponentsInChildren(typeof(MeshFilter));
Component[] array = componentsInChildren;
for (int i = 0; i < array.Length; i++)
{
MeshFilter meshFilter = (MeshFilter)array[i];
if (meshFilter.sharedMesh != null)
{
Mesh sharedMesh = meshFilter.sharedMesh;
TreeAO.CalcSoftOcclusion(sharedMesh);
Bounds bounds = sharedMesh.bounds;
Color[] array2 = sharedMesh.colors;
Vector3[] vertices = sharedMesh.vertices;
Vector4[] tangents = sharedMesh.tangents;
if (array2.Length == 0)
{
array2 = new Color[sharedMesh.vertexCount];
for (int j = 0; j < array2.Length; j++)
{
array2[j] = Color.white;
}
}
float b = 0f;
for (int k = 0; k < tangents.Length; k++)
{
b = Mathf.Max(tangents[k].w, b);
}
float num = 0f;
for (int l = 0; l < array2.Length; l++)
{
Vector2 vector = new Vector2(vertices[l].x, vertices[l].z);
float magnitude = vector.magnitude;
num = Mathf.Max(magnitude, num);
}
for (int m = 0; m < array2.Length; m++)
{
Vector2 vector2 = new Vector2(vertices[m].x, vertices[m].z);
float num2 = vector2.magnitude / num;
float num3 = (vertices[m].y - bounds.min.y) / bounds.size.y;
array2[m].a = num3 * num2 * 0.6f + num3 * 0.5f;
}
sharedMesh.colors = array2;
}
}
}
}
public static void CalcSoftOcclusion(Mesh mesh)
{
GameObject gameObject = new GameObject("Test");
gameObject.layer = 29;
MeshFilter meshFilter = gameObject.AddComponent <MeshFilter>();
meshFilter.mesh = mesh;
gameObject.AddComponent <MeshCollider>();
if (TreeAO.directions == null)
{
TreeAO.InitializeDirections();
}
Vector4[] array = new Vector4[TreeAO.directions.Length];
for (int i = 0; i < TreeAO.directions.Length; i++)
{
array[i] = new Vector4(TreeAO.GetWeight(1, TreeAO.directions[i]), TreeAO.GetWeight(2, TreeAO.directions[i]), TreeAO.GetWeight(3, TreeAO.directions[i]), TreeAO.GetWeight(0, TreeAO.directions[i]));
}
Vector3[] vertices = mesh.vertices;
Vector4[] array2 = new Vector4[vertices.Length];
float num = 0f;
for (int j = 0; j < vertices.Length; j++)
{
Vector4 vector = Vector4.zero;
Vector3 v = gameObject.transform.TransformPoint(vertices[j]);
for (int k = 0; k < TreeAO.directions.Length; k++)
{
float num2 = (float)TreeAO.CountIntersections(v, gameObject.transform.TransformDirection(TreeAO.directions[k]), 3f);
num2 = Mathf.Pow(0.5f, num2);
vector += array[k] * num2;
}
vector /= (float)TreeAO.directions.Length;
num += vector.w;
array2[j] = vector;
}
num /= (float)vertices.Length;
for (int l = 0; l < vertices.Length; l++)
{
Vector4[] expr_1D4_cp_0 = array2;
int expr_1D4_cp_1 = l;
expr_1D4_cp_0[expr_1D4_cp_1].w = expr_1D4_cp_0[expr_1D4_cp_1].w - num;
}
mesh.tangents = array2;
UnityEngine.Object.DestroyImmediate(gameObject);
}
private void OnPostprocessModel(GameObject root)
{
if (base.assetPath.ToLower().IndexOf("ambient-occlusion") != -1)
{
Component[] componentsInChildren = root.GetComponentsInChildren(typeof(MeshFilter));
foreach (MeshFilter filter in componentsInChildren)
{
if (filter.sharedMesh != null)
{
Mesh sharedMesh = filter.sharedMesh;
TreeAO.CalcSoftOcclusion(sharedMesh);
Bounds bounds = sharedMesh.bounds;
Color[] colors = sharedMesh.colors;
Vector3[] vertices = sharedMesh.vertices;
Vector4[] tangents = sharedMesh.tangents;
if (colors.Length == 0)
{
colors = new Color[sharedMesh.vertexCount];
for (int m = 0; m < colors.Length; m++)
{
colors[m] = Color.white;
}
}
float b = 0f;
for (int i = 0; i < tangents.Length; i++)
{
b = Mathf.Max(tangents[i].w, b);
}
float num5 = 0f;
for (int j = 0; j < colors.Length; j++)
{
Vector2 vector = new Vector2(vertices[j].x, vertices[j].z);
num5 = Mathf.Max(vector.magnitude, num5);
}
for (int k = 0; k < colors.Length; k++)
{
Vector2 vector2 = new Vector2(vertices[k].x, vertices[k].z);
float num9 = vector2.magnitude / num5;
float num10 = (vertices[k].y - bounds.min.y) / bounds.size.y;
colors[k].a = ((num10 * num9) * 0.6f) + (num10 * 0.5f);
}
sharedMesh.colors = colors;
}
}
}
}
private void OnPostprocessModel(GameObject root)
{
if (this.assetPath.ToLower().IndexOf("ambient-occlusion") == -1)
{
return;
}
foreach (MeshFilter componentsInChild in root.GetComponentsInChildren(typeof(MeshFilter)))
{
if ((Object)componentsInChild.sharedMesh != (Object)null)
{
Mesh sharedMesh = componentsInChild.sharedMesh;
TreeAO.CalcSoftOcclusion(sharedMesh);
Bounds bounds = sharedMesh.bounds;
Color[] colorArray = sharedMesh.colors;
Vector3[] vertices = sharedMesh.vertices;
Vector4[] tangents = sharedMesh.tangents;
if (colorArray.Length == 0)
{
colorArray = new Color[sharedMesh.vertexCount];
for (int index = 0; index < colorArray.Length; ++index)
{
colorArray[index] = Color.white;
}
}
float b1 = 0.0f;
for (int index = 0; index < tangents.Length; ++index)
{
b1 = Mathf.Max(tangents[index].w, b1);
}
float b2 = 0.0f;
for (int index = 0; index < colorArray.Length; ++index)
{
b2 = Mathf.Max(new Vector2(vertices[index].x, vertices[index].z).magnitude, b2);
}
for (int index = 0; index < colorArray.Length; ++index)
{
float num1 = new Vector2(vertices[index].x, vertices[index].z).magnitude / b2;
float num2 = (vertices[index].y - bounds.min.y) / bounds.size.y;
colorArray[index].a = (float)((double)num2 * (double)num1 * 0.600000023841858 + (double)num2 * 0.5);
}
sharedMesh.colors = colorArray;
}
}
}
public static void CalcSoftOcclusion(Mesh mesh)
{
GameObject gameObject = new GameObject("Test");
gameObject.layer = 29;
gameObject.AddComponent <MeshFilter>().mesh = mesh;
gameObject.AddComponent <MeshCollider>();
if (TreeAO.directions == null)
{
TreeAO.InitializeDirections();
}
Vector4[] vector4Array1 = new Vector4[TreeAO.directions.Length];
for (int index = 0; index < TreeAO.directions.Length; ++index)
{
vector4Array1[index] = new Vector4(TreeAO.GetWeight(1, TreeAO.directions[index]), TreeAO.GetWeight(2, TreeAO.directions[index]), TreeAO.GetWeight(3, TreeAO.directions[index]), TreeAO.GetWeight(0, TreeAO.directions[index]));
}
Vector3[] vertices = mesh.vertices;
Vector4[] vector4Array2 = new Vector4[vertices.Length];
float num1 = 0.0f;
for (int index1 = 0; index1 < vertices.Length; ++index1)
{
Vector4 zero = Vector4.zero;
Vector3 v = gameObject.transform.TransformPoint(vertices[index1]);
for (int index2 = 0; index2 < TreeAO.directions.Length; ++index2)
{
float num2 = Mathf.Pow(0.5f, (float)TreeAO.CountIntersections(v, gameObject.transform.TransformDirection(TreeAO.directions[index2]), 3f));
zero += vector4Array1[index2] * num2;
}
zero /= (float)TreeAO.directions.Length;
num1 += zero.w;
vector4Array2[index1] = zero;
}
float num3 = num1 / (float)vertices.Length;
for (int index = 0; index < vertices.Length; ++index)
{
vector4Array2[index].w -= num3;
}
mesh.tangents = vector4Array2;
Object.DestroyImmediate((Object)gameObject);
}
