*renameHEADmaster

1 files changed, 339 insertions, 0 deletions

diff --git a/Thronefall_v1.0/Decompile/PathMesher.cs b/Thronefall_v1.0/Decompile/PathMesher.cs
new file mode 100644
index 0000000..244ee39
--- /dev/null
+++ b/Thronefall_v1.0/Decompile/PathMesher.cs
@@ -0,0 +1,339 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+[RequireComponent(typeof(MeshRenderer))]
+[RequireComponent(typeof(MeshFilter))]
+[ExecuteInEditMode]
+public class PathMesher : MonoBehaviour
+{
+	public enum UnwrapMode
+	{
+		XZWorldSpace,
+		River
+	}
+
+	[Serializable]
+	public class PathPoint
+	{
+		public Vector3 position;
+
+		public float width;
+
+		public PathPoint(Vector3 _position, float _width)
+		{
+			position = _position;
+			width = _width;
+		}
+	}
+
+	private MeshFilter meshFilter;
+
+	private MeshCollider meshCollider;
+
+	public int subdivisions = 3;
+
+	public float vertDistance = 0.2f;
+
+	public int endCapSubdivisions = 3;
+
+	public float widthWhobble = 0.5f;
+
+	public float positionWhobble = 0.5f;
+
+	public UnwrapMode uvUnwrapMode;
+
+	public float uvScale = 0.01f;
+
+	public bool topNormalsAlwaysFaceDirectlyUp;
+
+	public Vector3 extrudeDownOffset;
+
+	public bool vertical;
+
+	public bool loop;
+
+	public bool flipNormals;
+
+	private List<FakeTransorm> transformsRemember = new List<FakeTransorm>();
+
+	private List<PathPoint> pathPoints = new List<PathPoint>();
+
+	public void UpdateMesh()
+	{
+		pathPoints.Clear();
+		for (int i = 0; i < base.transform.childCount; i++)
+		{
+			Transform child = base.transform.GetChild(i);
+			pathPoints.Add(new PathPoint(child.localPosition, child.localScale.x));
+		}
+		if (pathPoints.Count < 2)
+		{
+			return;
+		}
+		if (loop)
+		{
+			Transform child2 = base.transform.GetChild(0);
+			pathPoints.Add(new PathPoint(child2.localPosition, child2.localScale.x));
+		}
+		meshFilter = GetComponent<MeshFilter>();
+		meshCollider = GetComponent<MeshCollider>();
+		Mesh mesh = new Mesh();
+		List<Vector3> list = new List<Vector3>();
+		List<Vector2> uvs = new List<Vector2>();
+		List<int> list2 = new List<int>();
+		List<int> list3 = new List<int>();
+		List<PathPoint> _pathOriginal = new List<PathPoint>();
+		InterpolateModifyer(pathPoints, _pathOriginal, subdivisions);
+		if (vertDistance > 0.1f)
+		{
+			ResampleModifyer(ref _pathOriginal, vertDistance, vertDistance / 10f);
+		}
+		AddRoundedEndsModifyer(_pathOriginal, endCapSubdivisions);
+		WhobbleModifyer(_pathOriginal, widthWhobble, positionWhobble);
+		float num = 0f;
+		for (int j = 0; j < _pathOriginal.Count; j++)
+		{
+			if (_pathOriginal.Count <= 1)
+			{
+				break;
+			}
+			Vector3 forwards = GetForwards(j, _pathOriginal);
+			Vector3 vector = Quaternion.Euler(0f, 90f, 0f) * forwards * _pathOriginal[j].width;
+			Vector3 vector2 = Quaternion.Euler(0f, -90f, 0f) * forwards * _pathOriginal[j].width;
+			if (vertical)
+			{
+				vector = Vector3.up * _pathOriginal[j].width;
+				vector2 = Vector3.down * _pathOriginal[j].width;
+			}
+			AddUnwrappedVertTop(_pathOriginal[j].position + vector, list, uvs, num, 0f - _pathOriginal[j].width);
+			AddUnwrappedVertTop(_pathOriginal[j].position + vector2, list, uvs, num, _pathOriginal[j].width);
+			if (j > 0)
+			{
+				num += (_pathOriginal[j].position - _pathOriginal[j - 1].position).magnitude;
+			}
+		}
+		int count = list.Count;
+		if (extrudeDownOffset.y != 0f)
+		{
+			num = 0f;
+			for (int k = 0; k <= 1; k++)
+			{
+				int num2 = 0;
+				for (int l = k; l < count - 2; l += 2)
+				{
+					AddUnwrappedVertTop(list[l], list, uvs, num, 0f);
+					AddUnwrappedVertTop(list[l] + extrudeDownOffset, list, uvs, num, 0f - extrudeDownOffset.magnitude);
+					num += (_pathOriginal[num2 + 1].position - _pathOriginal[num2].position).magnitude;
+					num2++;
+					AddUnwrappedVertTop(list[l + 2], list, uvs, num, 0f);
+					AddUnwrappedVertTop(list[l + 2] + extrudeDownOffset, list, uvs, num, 0f - extrudeDownOffset.magnitude);
+				}
+			}
+		}
+		Vector3[] normals = new Vector3[list.Count];
+		for (int m = 0; m < _pathOriginal.Count - 1; m++)
+		{
+			if (_pathOriginal.Count <= 1)
+			{
+				break;
+			}
+			int num3 = m * 2;
+			ConnectTriangle(num3 + 2, num3 + 1, num3, list2, normals, list, topNormalsAlwaysFaceDirectlyUp, vertical);
+			ConnectTriangle(num3 + 1, num3 + 2, num3 + 3, list2, normals, list, topNormalsAlwaysFaceDirectlyUp, vertical);
+		}
+		if (extrudeDownOffset.y != 0f)
+		{
+			int num4 = count;
+			for (int n = 0; n < count - 2; n += 2)
+			{
+				ConnectTriangle(num4, num4 + 1, num4 + 2, list3, normals, list, _makeNormalsFaceUp: false, _showFacesFacedDownwards: true);
+				ConnectTriangle(num4 + 3, num4 + 2, num4 + 1, list3, normals, list, _makeNormalsFaceUp: false, _showFacesFacedDownwards: true);
+				num4 += 4;
+			}
+			int num5 = num4;
+			for (int num6 = 1; num6 < count - 2; num6 += 2)
+			{
+				ConnectTriangle(num4 + 2, num4 + 1, num4, list3, normals, list, _makeNormalsFaceUp: false, _showFacesFacedDownwards: true);
+				ConnectTriangle(num4 + 1, num4 + 2, num4 + 3, list3, normals, list, _makeNormalsFaceUp: false, _showFacesFacedDownwards: true);
+				num4 += 4;
+			}
+			ConnectTriangle(num5, count + 1, count, list3, normals, list, _makeNormalsFaceUp: false, _showFacesFacedDownwards: true);
+			ConnectTriangle(count + 1, num5, num5 + 1, list3, normals, list, _makeNormalsFaceUp: false, _showFacesFacedDownwards: true);
+			ConnectTriangle(num5 - 2, num5 - 1, num4 - 2, list3, normals, list, _makeNormalsFaceUp: false, _showFacesFacedDownwards: true);
+			ConnectTriangle(num4 - 1, num4 - 2, num5 - 1, list3, normals, list, _makeNormalsFaceUp: false, _showFacesFacedDownwards: true);
+		}
+		mesh.subMeshCount = ((extrudeDownOffset.y == 0f) ? 1 : 2);
+		mesh.SetVertices(list);
+		mesh.SetTriangles(list2, 0);
+		if (extrudeDownOffset.y != 0f)
+		{
+			mesh.SetTriangles(list3, 1);
+		}
+		mesh.SetUVs(0, uvs);
+		mesh.SetNormals(normals);
+		mesh.RecalculateBounds();
+		if ((bool)meshFilter)
+		{
+			meshFilter.sharedMesh = mesh;
+		}
+		if ((bool)meshCollider)
+		{
+			meshCollider.sharedMesh = mesh;
+		}
+	}
+
+	public void ConnectTriangle(int _vertA, int _vertB, int _vertC, List<int> _tris, Vector3[] _normals, List<Vector3> _verts, bool _makeNormalsFaceUp, bool _showFacesFacedDownwards)
+	{
+		if (flipNormals)
+		{
+			int num = _vertA;
+			_vertA = _vertC;
+			_vertC = num;
+		}
+		Vector3 normalized = Vector3.Cross(_verts[_vertA] - _verts[_vertB], _verts[_vertC] - _verts[_vertB]).normalized;
+		if (normalized.y > 0f || _showFacesFacedDownwards)
+		{
+			_tris.Add(_vertC);
+			_tris.Add(_vertB);
+			_tris.Add(_vertA);
+			if (_makeNormalsFaceUp)
+			{
+				_normals[_vertC] = Vector3.up;
+				_normals[_vertB] = Vector3.up;
+				_normals[_vertA] = Vector3.up;
+			}
+			else
+			{
+				_normals[_vertC] = normalized;
+				_normals[_vertB] = normalized;
+				_normals[_vertA] = normalized;
+			}
+		}
+	}
+
+	public void AddUnwrappedVertTop(Vector3 _pos, List<Vector3> _verts, List<Vector2> _uvs, float _distanceTraveled, float _width)
+	{
+		_verts.Add(_pos);
+		if (uvUnwrapMode == UnwrapMode.XZWorldSpace)
+		{
+			_pos = base.transform.localToWorldMatrix.MultiplyPoint(_pos);
+			_uvs.Add(new Vector2(_pos.x * uvScale, _pos.z * uvScale));
+		}
+		else if (uvUnwrapMode == UnwrapMode.River)
+		{
+			_uvs.Add(new Vector2(_distanceTraveled * uvScale, _width * uvScale));
+		}
+	}
+
+	public void InterpolateModifyer(List<PathPoint> _pathIn, List<PathPoint> _pathOut, int _subdivisions)
+	{
+		for (int i = 0; i < _pathIn.Count - 1; i++)
+		{
+			for (int j = 0; j < _subdivisions; j++)
+			{
+				float num = (float)j / (float)_subdivisions;
+				float magnitude = (_pathIn[i + 1].position - _pathIn[i].position).magnitude;
+				Vector3 forwards = GetForwards(i, _pathIn);
+				Vector3 forwards2 = GetForwards(i + 1, _pathIn);
+				Vector3 a = _pathIn[i].position + num * forwards * magnitude;
+				Vector3 b = _pathIn[i + 1].position - (1f - num) * forwards2 * magnitude;
+				Vector3 position = Vector3.Lerp(a, b, Mathf.SmoothStep(0f, 1f, num));
+				float width = Mathf.SmoothStep(_pathIn[i].width, _pathIn[i + 1].width, num);
+				PathPoint item = new PathPoint(position, width);
+				_pathOut.Add(item);
+			}
+		}
+		_pathOut.Add(_pathIn[_pathIn.Count - 1]);
+	}
+
+	public void ResampleModifyer(ref List<PathPoint> _pathOriginal, float _maxDistance, float _stepSize = 0.1f)
+	{
+		if (_pathOriginal.Count < 2)
+		{
+			return;
+		}
+		List<PathPoint> list = new List<PathPoint>();
+		list.Add(_pathOriginal[0]);
+		float num = 0f;
+		for (int i = 0; i < _pathOriginal.Count - 1; i++)
+		{
+			int num2 = (int)Mathf.Ceil((_pathOriginal[i].position - _pathOriginal[i + 1].position).magnitude / _stepSize);
+			for (int j = 0; j < num2; j++)
+			{
+				num += _stepSize;
+				if (num >= _maxDistance)
+				{
+					float t = (float)j / (float)num2;
+					Vector3 position = Vector3.Lerp(_pathOriginal[i].position, _pathOriginal[i + 1].position, t);
+					float width = Mathf.Lerp(_pathOriginal[i].width, _pathOriginal[i + 1].width, t);
+					num = 0f;
+					list.Add(new PathPoint(position, width));
+				}
+			}
+		}
+		list.Add(_pathOriginal[_pathOriginal.Count - 1]);
+		_pathOriginal = list;
+	}
+
+	public void WhobbleModifyer(List<PathPoint> _path, float _widthAmount, float _posAmount)
+	{
+		UnityEngine.Random.InitState(_path.Count * 7);
+		for (int i = 0; i < _path.Count; i++)
+		{
+			_path[i].position += new Vector3(UnityEngine.Random.value - 0.5f, 0f, UnityEngine.Random.value - 0.5f) * _posAmount;
+			_path[i].width *= 1f + (UnityEngine.Random.value - 0.5f) * _widthAmount;
+		}
+	}
+
+	public void AddRoundedEndsModifyer(List<PathPoint> _pathModify, int _interpolations)
+	{
+		Vector3 position = _pathModify[0].position;
+		Vector3 vector = -GetForwards(0, _pathModify);
+		float width = _pathModify[0].width;
+		Vector3 position2 = _pathModify[_pathModify.Count - 1].position;
+		Vector3 forwards = GetForwards(_pathModify.Count - 1, _pathModify);
+		float width2 = _pathModify[_pathModify.Count - 1].width;
+		for (int i = 1; i < _interpolations; i++)
+		{
+			float f = (float)i / (float)_interpolations;
+			f = Mathf.Pow(f, 0.5f);
+			float width3 = width * (1f - Mathf.Pow(f, 3f));
+			float num = width * f;
+			_pathModify.Insert(0, new PathPoint(position + num * vector, width3));
+		}
+		for (int j = 1; j < _interpolations; j++)
+		{
+			float f2 = (float)j / (float)_interpolations;
+			f2 = Mathf.Pow(f2, 0.5f);
+			float width4 = width2 * (1f - Mathf.Pow(f2, 3f));
+			float num2 = width2 * f2;
+			_pathModify.Add(new PathPoint(position2 + num2 * forwards, width4));
+		}
+	}
+
+	private Vector3 GetForwards(int i, List<PathPoint> path, bool _xzPlaneOnly = true)
+	{
+		Vector3 result = ((i == 0) ? (path[i + 1].position - path[i].position).normalized : ((i != path.Count - 1) ? (path[i + 1].position - path[i - 1].position).normalized : (path[i].position - path[i - 1].position).normalized));
+		if (_xzPlaneOnly)
+		{
+			result = new Vector3(result.x, 0f, result.z).normalized;
+		}
+		return result;
+	}
+
+	public void Nullify()
+	{
+		List<Vector3> list = new List<Vector3>();
+		for (int i = 0; i < base.transform.childCount; i++)
+		{
+			Transform child = base.transform.GetChild(i);
+			list.Add(child.transform.position);
+		}
+		base.transform.position = Vector3.zero;
+		for (int j = 0; j < base.transform.childCount; j++)
+		{
+			base.transform.GetChild(j).transform.position = list[j];
+		}
+	}
+}