using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

namespace CTS
{
	[Serializable]
	[ExecuteInEditMode]
	public class CTSMeshBlender : MonoBehaviour
	{
		[Serializable]
		public class TextureData
		{
			public int m_terrainIdx;

			public float m_terrainTextureStrength;

			public Texture2D m_albedo;

			public Texture2D m_normal;

			public Texture2D m_hao_in_GA;

			public float m_tiling;

			public Vector4 m_color;

			public float m_normalPower;

			public float m_aoPower;

			public float m_geoPower;

			public float m_heightContrast = 1f;

			public float m_heightDepth = 1f;

			public float m_heightBlendClose = 1f;
		}

		public float m_textureBlendOffset = -2f;

		public float m_textureBlendStart = 2f;

		public float m_textureBlendHeight = 1f;

		public float m_normalBlendOffset = -1f;

		public float m_normalBlendStart;

		public float m_normalBlendHeight = 2f;

		public float m_specular = 1f;

		public float m_smoothness = 1f;

		public bool m_useAO = true;

		public bool m_useAOTexture;

		public float m_geoMapClosePower;

		public float m_geoTilingClose = 1f;

		public float m_geoMapOffsetClose = 86f;

		public Texture2D m_geoMap;

		public Material m_sharedMaterial;

		public List<TextureData> m_textureList = new List<TextureData>();

		private MaterialPropertyBlock m_materialProperties;

		[SerializeField]
		private MeshRenderer[] m_renderers;

		[SerializeField]
		private MeshFilter[] m_filters;

		[SerializeField]
		private Mesh[] m_originalMeshes;

		private static bool _ShadersIDsAreInitialized;

		private static int _Use_AO;

		private static int _Use_AO_Texture;

		private static int _Terrain_Specular;

		private static int _Terrain_Smoothness;

		private static int _Texture_Geological_Map;

		private static int _Geological_Tiling_Close;

		private static int _Geological_Map_Offset_Close;

		private static int _Geological_Map_Close_Power;

		private static int _Texture_Albedo_Sm_1;

		private static int _Texture_Color_1;

		private static int _Texture_Tiling_1;

		private static int _Texture_Normal_1;

		private static int _Texture_1_Normal_Power;

		private static int _Texture_GHeightAAO_1;

		private static int _Texture_1_AO_Power;

		private static int _Texture_1_Geological_Power;

		private static int _Texture_1_Height_Contrast;

		private static int _Texture_1_Heightmap_Depth;

		private static int _Texture_1_Heightblend_Close;

		private static int _Texture_Albedo_Sm_2;

		private static int _Texture_Color_2;

		private static int _Texture_Tiling_2;

		private static int _Texture_Normal_2;

		private static int _Texture_2_Normal_Power;

		private static int _Texture_GHeightAAO_2;

		private static int _Texture_2_AO_Power;

		private static int _Texture_2_Geological_Power;

		private static int _Texture_2_Height_Contrast;

		private static int _Texture_2_Heightmap_Depth;

		private static int _Texture_2_Heightblend_Close;

		private static int _Texture_Albedo_Sm_3;

		private static int _Texture_Color_3;

		private static int _Texture_Tiling_3;

		private static int _Texture_Normal_3;

		private static int _Texture_3_Normal_Power;

		private static int _Texture_GHeightAAO_3;

		private static int _Texture_3_AO_Power;

		private static int _Texture_3_Geological_Power;

		private static int _Texture_3_Height_Contrast;

		private static int _Texture_3_Heightmap_Depth;

		private static int _Texture_3_Heightblend_Close;

		private void Awake()
		{
		}

		public void ClearBlend()
		{
			if (m_filters != null)
			{
				for (int i = 0; i < m_filters.Length; i++)
				{
					m_filters[i].sharedMesh = m_originalMeshes[i];
				}
			}
			if (m_renderers != null)
			{
				for (int j = 0; j < m_renderers.Length; j++)
				{
					MeshRenderer meshRenderer = m_renderers[j];
					List<Material> list = new List<Material>(meshRenderer.sharedMaterials);
					int num = 0;
					while (num < list.Count)
					{
						Material material = list[num];
						if (material == null || material.name == "CTS Model Blend Shader")
						{
							list.RemoveAt(num);
							m_sharedMaterial = material;
						}
						else
						{
							num++;
						}
					}
					meshRenderer.sharedMaterials = list.ToArray();
				}
			}
			if (m_sharedMaterial != null)
			{
				UnityEngine.Object.DestroyImmediate(m_sharedMaterial);
				m_sharedMaterial = null;
			}
			m_renderers = null;
			m_filters = null;
			m_originalMeshes = null;
			m_textureList.Clear();
		}

		public void CreateBlend()
		{
			ClearBlend();
			m_renderers = base.gameObject.GetComponentsInChildren<MeshRenderer>();
			m_filters = base.gameObject.GetComponentsInChildren<MeshFilter>();
			m_originalMeshes = new Mesh[m_filters.Length];
			for (int i = 0; i < m_filters.Length; i++)
			{
				if (m_filters[i].sharedMesh == null)
				{
					m_originalMeshes[i] = null;
					continue;
				}
				m_originalMeshes[i] = m_filters[i].sharedMesh;
				m_filters[i].sharedMesh = UnityEngine.Object.Instantiate(m_originalMeshes[i]);
			}
			GetTexturesAndSettingsAtCurrentLocation();
			Vector3 position = base.transform.position;
			Vector3 localScale = base.transform.localScale;
			Vector3 eulerAngles = base.transform.eulerAngles;
			for (int j = 0; j < m_filters.Length; j++)
			{
				Mesh sharedMesh = m_filters[j].sharedMesh;
				if (!(sharedMesh != null))
				{
					continue;
				}
				int num = sharedMesh.vertices.Length;
				Vector3[] vertices = sharedMesh.vertices;
				Vector3[] normals = sharedMesh.normals;
				Color[] array = sharedMesh.colors;
				if (array.Length == 0)
				{
					array = new Color[num];
				}
				for (int k = 0; k < num; k++)
				{
					Vector3 vector = position + Quaternion.Euler(eulerAngles) * Vector3.Scale(vertices[k], localScale);
					Terrain terrain = GetTerrain(vector);
					if (terrain != null)
					{
						Vector3 localPosition = GetLocalPosition(terrain, vector);
						float num2 = terrain.SampleHeight(vector);
						float num3 = num2 + m_textureBlendOffset;
						float num4 = num3 + m_textureBlendStart;
						float num5 = num4 + m_textureBlendHeight;
						float num6 = num2 + m_normalBlendOffset;
						float num7 = num6 + m_normalBlendStart;
						float num8 = num7 + m_normalBlendHeight;
						if (vector.y < num3)
						{
							array[k].a = 0f;
						}
						else if (vector.y <= num5)
						{
							Color color = default(Color);
							float a = 1f;
							if (vector.y > num4)
							{
								a = Mathf.Lerp(1f, 0f, (vector.y - num4) / m_textureBlendHeight);
							}
							color.a = a;
							float[,,] texturesAtLocation = GetTexturesAtLocation(terrain, localPosition);
							if (m_textureList.Count >= 1)
							{
								color.r = texturesAtLocation[0, 0, m_textureList[0].m_terrainIdx];
							}
							if (m_textureList.Count >= 2)
							{
								color.g = texturesAtLocation[0, 0, m_textureList[1].m_terrainIdx];
							}
							if (m_textureList.Count >= 3)
							{
								color.b = texturesAtLocation[0, 0, m_textureList[2].m_terrainIdx];
							}
							array[k] = color;
						}
						else
						{
							array[k].a = 0f;
						}
						if (vector.y >= num6)
						{
							if (vector.y < num7)
							{
								normals[k] = GetNormalsAtLocation(terrain, localPosition);
							}
							else if (vector.y <= num8)
							{
								normals[k] = Vector3.Lerp(GetNormalsAtLocation(terrain, localPosition), normals[k], (num8 - vector.y) / m_normalBlendHeight);
							}
						}
					}
					else
					{
						array[k].a = 0f;
					}
				}
				sharedMesh.colors = array;
				sharedMesh.normals = normals;
			}
			InitializeMaterials();
			UpdateShader();
		}

		public Vector3 GetNearestVertice(Vector3 sourcePosition, GameObject targetObject)
		{
			float num = float.MaxValue;
			Vector3 vector = targetObject.transform.position;
			Vector3 vector2 = vector;
			Vector3 localScale = targetObject.transform.localScale;
			Vector3 eulerAngles = targetObject.transform.eulerAngles;
			MeshFilter[] componentsInChildren = targetObject.GetComponentsInChildren<MeshFilter>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Mesh sharedMesh = componentsInChildren[i].sharedMesh;
				if (!(sharedMesh != null))
				{
					continue;
				}
				int num2 = sharedMesh.vertices.Length;
				Vector3[] vertices = sharedMesh.vertices;
				for (int j = 0; j < num2; j++)
				{
					Vector3 vector3 = vector2 + Quaternion.Euler(eulerAngles) * Vector3.Scale(vertices[j], localScale);
					float num3 = Vector3.Distance(sourcePosition, vector3);
					if (num3 < num)
					{
						num = num3;
						vector = vector3;
					}
				}
			}
			return vector;
		}

		private void InitializeShaderConstants()
		{
			if (!_ShadersIDsAreInitialized)
			{
				Debug.Log("Initialising shader IDs");
				_ShadersIDsAreInitialized = true;
				_Use_AO = Shader.PropertyToID("_Use_AO");
				_Use_AO_Texture = Shader.PropertyToID("_Use_AO_Texture");
				_Terrain_Specular = Shader.PropertyToID("_Terrain_Specular");
				_Terrain_Smoothness = Shader.PropertyToID("_Terrain_Smoothness");
				_Texture_Geological_Map = Shader.PropertyToID("_Texture_Geological_Map");
				_Geological_Tiling_Close = Shader.PropertyToID("_Geological_Tiling_Close");
				_Geological_Map_Offset_Close = Shader.PropertyToID("_Geological_Map_Offset_Close");
				_Geological_Map_Close_Power = Shader.PropertyToID("_Geological_Map_Close_Power");
				_Texture_Albedo_Sm_1 = Shader.PropertyToID("_Texture_Albedo_Sm_1");
				_Texture_Color_1 = Shader.PropertyToID("_Texture_Color_1");
				_Texture_Tiling_1 = Shader.PropertyToID("_Texture_Tiling_1");
				_Texture_Normal_1 = Shader.PropertyToID("_Texture_Normal_1");
				_Texture_1_Normal_Power = Shader.PropertyToID("_Texture_1_Normal_Power");
				_Texture_GHeightAAO_1 = Shader.PropertyToID("_Texture_GHeightAAO_1");
				_Texture_1_AO_Power = Shader.PropertyToID("_Texture_1_AO_Power");
				_Texture_1_Geological_Power = Shader.PropertyToID("_Texture_1_Geological_Power");
				_Texture_1_Height_Contrast = Shader.PropertyToID("_Texture_1_Height_Contrast");
				_Texture_1_Heightmap_Depth = Shader.PropertyToID("_Texture_1_Heightmap_Depth");
				_Texture_1_Heightblend_Close = Shader.PropertyToID("_Texture_1_Heightblend_Close");
				_Texture_Albedo_Sm_2 = Shader.PropertyToID("_Texture_Albedo_Sm_2");
				_Texture_Color_2 = Shader.PropertyToID("_Texture_Color_2");
				_Texture_Tiling_2 = Shader.PropertyToID("_Texture_Tiling_2");
				_Texture_Normal_2 = Shader.PropertyToID("_Texture_Normal_2");
				_Texture_2_Normal_Power = Shader.PropertyToID("_Texture_2_Normal_Power");
				_Texture_GHeightAAO_2 = Shader.PropertyToID("_Texture_GHeightAAO_2");
				_Texture_2_AO_Power = Shader.PropertyToID("_Texture_2_AO_Power");
				_Texture_2_Geological_Power = Shader.PropertyToID("_Texture_2_Geological_Power");
				_Texture_2_Height_Contrast = Shader.PropertyToID("_Texture_2_Height_Contrast");
				_Texture_2_Heightmap_Depth = Shader.PropertyToID("_Texture_2_Heightmap_Depth");
				_Texture_2_Heightblend_Close = Shader.PropertyToID("_Texture_2_Heightblend_Close");
				_Texture_Albedo_Sm_3 = Shader.PropertyToID("_Texture_Albedo_Sm_3");
				_Texture_Color_3 = Shader.PropertyToID("_Texture_Color_3");
				_Texture_Tiling_3 = Shader.PropertyToID("_Texture_Tiling_3");
				_Texture_Normal_3 = Shader.PropertyToID("_Texture_Normal_3");
				_Texture_3_Normal_Power = Shader.PropertyToID("_Texture_3_Normal_Power");
				_Texture_GHeightAAO_3 = Shader.PropertyToID("_Texture_GHeightAAO_3");
				_Texture_3_AO_Power = Shader.PropertyToID("_Texture_3_AO_Power");
				_Texture_3_Geological_Power = Shader.PropertyToID("_Texture_3_Geological_Power");
				_Texture_3_Height_Contrast = Shader.PropertyToID("_Texture_3_Height_Contrast");
				_Texture_3_Heightmap_Depth = Shader.PropertyToID("_Texture_3_Heightmap_Depth");
				_Texture_3_Heightblend_Close = Shader.PropertyToID("_Texture_3_Heightblend_Close");
			}
		}

		private void InitializeMaterials()
		{
			for (int i = 0; i < m_renderers.Length; i++)
			{
				MeshRenderer meshRenderer = m_renderers[i];
				if (meshRenderer != null)
				{
					bool flag = false;
					List<Material> list = new List<Material>(m_renderers[i].sharedMaterials);
					for (int j = 0; j < list.Count; j++)
					{
						if (list[j].name == "CTS Model Blend Shader")
						{
							flag = true;
							m_sharedMaterial = list[j];
							break;
						}
					}
					if (!flag)
					{
						if (m_sharedMaterial == null)
						{
							m_sharedMaterial = new Material(Shader.Find("CTS/CTS_Model_Blend"))
							{
								name = "CTS Model Blend Shader"
							};
						}
						list.Add(m_sharedMaterial);
						meshRenderer.sharedMaterials = list.ToArray();
					}
				}
				else
				{
					Debug.LogWarning("Got nulll renderer!");
				}
			}
		}

		private void UpdateShader()
		{
			InitializeShaderConstants();
			if (m_sharedMaterial == null)
			{
				Debug.LogWarning("CTS Blender Missing Material. Exiting without updating.");
				return;
			}
			if (m_renderers == null || m_renderers.Length == 0)
			{
				Debug.LogWarning("CTS Blender Missing Renderer. Exiting without updating.");
				return;
			}
			if (m_textureList.Count == 0)
			{
				Debug.LogWarning("CTS Blender has no textures. Exiting without updating.");
				return;
			}
			if (m_materialProperties == null)
			{
				m_materialProperties = new MaterialPropertyBlock();
			}
			for (int i = 0; i < m_renderers.Length; i++)
			{
				m_sharedMaterial.SetInt(_Use_AO, m_useAO ? 1 : 0);
				m_sharedMaterial.SetInt(_Use_AO_Texture, m_useAOTexture ? 1 : 0);
				m_sharedMaterial.SetFloat(_Terrain_Specular, m_specular);
				m_sharedMaterial.SetFloat(_Terrain_Smoothness, m_smoothness);
				m_sharedMaterial.SetTexture(_Texture_Geological_Map, m_geoMap);
				m_sharedMaterial.SetFloat(_Geological_Tiling_Close, m_geoTilingClose);
				m_sharedMaterial.SetFloat(_Geological_Map_Offset_Close, m_geoMapOffsetClose);
				m_sharedMaterial.SetFloat(_Geological_Map_Close_Power, m_geoMapClosePower);
				if (m_textureList.Count >= 1)
				{
					TextureData textureData = m_textureList[0];
					m_sharedMaterial.SetTexture(_Texture_Albedo_Sm_1, textureData.m_albedo);
					m_sharedMaterial.SetTexture(_Texture_Normal_1, textureData.m_normal);
					m_sharedMaterial.SetTexture(_Texture_GHeightAAO_1, textureData.m_hao_in_GA);
					m_sharedMaterial.SetVector(_Texture_Color_1, textureData.m_color);
					m_sharedMaterial.SetFloat(_Texture_Tiling_1, textureData.m_tiling);
					m_sharedMaterial.SetFloat(_Texture_1_Normal_Power, textureData.m_normalPower);
					m_sharedMaterial.SetFloat(_Texture_1_AO_Power, textureData.m_aoPower);
					m_sharedMaterial.SetFloat(_Texture_1_Geological_Power, textureData.m_geoPower);
					m_sharedMaterial.SetFloat(_Texture_1_Height_Contrast, textureData.m_heightContrast);
					m_sharedMaterial.SetFloat(_Texture_1_Heightmap_Depth, textureData.m_heightDepth);
					m_sharedMaterial.SetFloat(_Texture_1_Heightblend_Close, textureData.m_heightBlendClose);
				}
				if (m_textureList.Count >= 2)
				{
					TextureData textureData2 = m_textureList[1];
					m_sharedMaterial.SetTexture(_Texture_Albedo_Sm_2, textureData2.m_albedo);
					m_sharedMaterial.SetTexture(_Texture_Normal_2, textureData2.m_normal);
					m_sharedMaterial.SetTexture(_Texture_GHeightAAO_2, textureData2.m_hao_in_GA);
					m_sharedMaterial.SetVector(_Texture_Color_2, textureData2.m_color);
					m_sharedMaterial.SetFloat(_Texture_Tiling_2, textureData2.m_tiling);
					m_sharedMaterial.SetFloat(_Texture_2_Normal_Power, textureData2.m_normalPower);
					m_sharedMaterial.SetFloat(_Texture_2_AO_Power, textureData2.m_aoPower);
					m_sharedMaterial.SetFloat(_Texture_2_Geological_Power, textureData2.m_geoPower);
					m_sharedMaterial.SetFloat(_Texture_2_Height_Contrast, textureData2.m_heightContrast);
					m_sharedMaterial.SetFloat(_Texture_2_Heightmap_Depth, textureData2.m_heightDepth);
					m_sharedMaterial.SetFloat(_Texture_2_Heightblend_Close, textureData2.m_heightBlendClose);
				}
				if (m_textureList.Count >= 3)
				{
					TextureData textureData3 = m_textureList[2];
					m_sharedMaterial.SetTexture(_Texture_Albedo_Sm_3, textureData3.m_albedo);
					m_sharedMaterial.SetTexture(_Texture_Normal_3, textureData3.m_normal);
					m_sharedMaterial.SetTexture(_Texture_GHeightAAO_3, textureData3.m_hao_in_GA);
					m_sharedMaterial.SetVector(_Texture_Color_3, textureData3.m_color);
					m_sharedMaterial.SetFloat(_Texture_Tiling_3, textureData3.m_tiling);
					m_sharedMaterial.SetFloat(_Texture_3_Normal_Power, textureData3.m_normalPower);
					m_sharedMaterial.SetFloat(_Texture_3_AO_Power, textureData3.m_aoPower);
					m_sharedMaterial.SetFloat(_Texture_3_Geological_Power, textureData3.m_geoPower);
					m_sharedMaterial.SetFloat(_Texture_3_Height_Contrast, textureData3.m_heightContrast);
					m_sharedMaterial.SetFloat(_Texture_3_Heightmap_Depth, textureData3.m_heightDepth);
					m_sharedMaterial.SetFloat(_Texture_3_Heightblend_Close, textureData3.m_heightBlendClose);
				}
			}
		}

		private void GetTexturesAndSettingsAtCurrentLocation()
		{
			m_textureList.Clear();
			CTSProfile cTSProfile = null;
			CTSSplatPrototype[] array = new CTSSplatPrototype[0];
			Vector3 position = base.transform.position;
			Vector3 localScale = base.transform.localScale;
			Vector3 eulerAngles = base.transform.eulerAngles;
			for (int num = m_filters.Length - 1; num >= 0; num--)
			{
				Mesh sharedMesh = m_filters[num].sharedMesh;
				if (sharedMesh != null)
				{
					Vector3[] vertices = sharedMesh.vertices;
					for (int num2 = vertices.Length - 1; num2 >= 0; num2--)
					{
						Vector3 locationWU = position + Quaternion.Euler(eulerAngles) * Vector3.Scale(vertices[num2], localScale);
						Terrain terrain = GetTerrain(locationWU);
						if (terrain != null)
						{
							if (cTSProfile == null)
							{
								CompleteTerrainShader component = terrain.gameObject.GetComponent<CompleteTerrainShader>();
								if (component != null)
								{
									cTSProfile = component.Profile;
								}
							}
							if (array.Length == 0)
							{
								array = CTSSplatPrototype.GetCTSSplatPrototypes(terrain);
							}
							Vector3 localPosition = GetLocalPosition(terrain, locationWU);
							float[,,] texturesAtLocation = GetTexturesAtLocation(terrain, localPosition);
							for (int i = 0; i < texturesAtLocation.GetLength(2); i++)
							{
								if (i == m_textureList.Count)
								{
									TextureData textureData = new TextureData();
									textureData.m_terrainIdx = i;
									textureData.m_terrainTextureStrength = texturesAtLocation[0, 0, i];
									m_textureList.Add(textureData);
								}
								else
								{
									m_textureList[i].m_terrainTextureStrength += texturesAtLocation[0, 0, i];
								}
							}
						}
					}
				}
			}
			List<TextureData> list = m_textureList.OrderByDescending((TextureData x) => x.m_terrainTextureStrength).ToList();
			while (list.Count > 3)
			{
				list.RemoveAt(list.Count - 1);
			}
			m_textureList = list.OrderBy((TextureData x) => x.m_terrainIdx).ToList();
			if (cTSProfile != null)
			{
				m_geoMap = cTSProfile.GeoAlbedo;
				m_geoMapClosePower = cTSProfile.m_geoMapClosePower;
				m_geoMapOffsetClose = cTSProfile.m_geoMapCloseOffset;
				m_geoTilingClose = cTSProfile.m_geoMapTilingClose;
				m_smoothness = cTSProfile.m_globalTerrainSmoothness;
				m_specular = cTSProfile.m_globalTerrainSpecular;
				switch (cTSProfile.m_globalAOType)
				{
				case CTSConstants.AOType.None:
					m_useAO = false;
					m_useAOTexture = false;
					break;
				case CTSConstants.AOType.NormalMapBased:
					m_useAO = true;
					m_useAOTexture = false;
					break;
				case CTSConstants.AOType.TextureBased:
					m_useAO = true;
					m_useAOTexture = true;
					break;
				}
			}
			else
			{
				m_geoMap = null;
				m_geoMapClosePower = 0f;
				m_geoMapOffsetClose = 0f;
				m_geoTilingClose = 0f;
				m_smoothness = 1f;
				m_specular = 1f;
				m_useAO = true;
				m_useAOTexture = false;
			}
			byte minHeight = 0;
			byte maxHeight = 0;
			for (int num3 = 0; num3 < m_textureList.Count; num3++)
			{
				TextureData textureData2 = m_textureList[num3];
				if (cTSProfile != null && textureData2.m_terrainIdx < cTSProfile.TerrainTextures.Count)
				{
					CTSTerrainTextureDetails cTSTerrainTextureDetails = cTSProfile.TerrainTextures[textureData2.m_terrainIdx];
					textureData2.m_albedo = cTSTerrainTextureDetails.Albedo;
					textureData2.m_normal = cTSTerrainTextureDetails.Normal;
					textureData2.m_hao_in_GA = cTSProfile.BakeHAOTexture(cTSTerrainTextureDetails.Albedo.name, cTSTerrainTextureDetails.Height, cTSTerrainTextureDetails.AmbientOcclusion, out minHeight, out maxHeight);
					textureData2.m_aoPower = cTSTerrainTextureDetails.m_aoPower;
					textureData2.m_color = new Vector4(cTSTerrainTextureDetails.m_tint.r * cTSTerrainTextureDetails.m_tintBrightness, cTSTerrainTextureDetails.m_tint.g * cTSTerrainTextureDetails.m_tintBrightness, cTSTerrainTextureDetails.m_tint.b * cTSTerrainTextureDetails.m_tintBrightness, cTSTerrainTextureDetails.m_smoothness);
					textureData2.m_geoPower = cTSTerrainTextureDetails.m_geologicalPower;
					textureData2.m_normalPower = cTSTerrainTextureDetails.m_normalStrength;
					textureData2.m_tiling = cTSTerrainTextureDetails.m_albedoTilingClose;
					textureData2.m_heightContrast = cTSTerrainTextureDetails.m_heightContrast;
					textureData2.m_heightDepth = cTSTerrainTextureDetails.m_heightDepth;
					textureData2.m_heightBlendClose = cTSTerrainTextureDetails.m_heightBlendClose;
				}
				else if (textureData2.m_terrainIdx < array.Length)
				{
					CTSSplatPrototype cTSSplatPrototype = array[textureData2.m_terrainIdx];
					textureData2.m_albedo = cTSSplatPrototype.texture;
					textureData2.m_normal = cTSSplatPrototype.normalMap;
					textureData2.m_hao_in_GA = null;
					textureData2.m_aoPower = 0f;
					textureData2.m_color = Vector4.one;
					textureData2.m_geoPower = 0f;
					textureData2.m_normalPower = 1f;
					textureData2.m_tiling = cTSSplatPrototype.tileSize.x;
					textureData2.m_heightContrast = 1f;
					textureData2.m_heightDepth = 1f;
					textureData2.m_heightBlendClose = 1f;
				}
			}
		}

		private Terrain GetTerrain(Vector3 locationWU)
		{
			Terrain activeTerrain = Terrain.activeTerrain;
			if (activeTerrain != null)
			{
				Vector3 position = activeTerrain.GetPosition();
				Vector3 vector = position + activeTerrain.terrainData.size;
				if (locationWU.x >= position.x && locationWU.x <= vector.x && locationWU.z >= position.z && locationWU.z <= vector.z)
				{
					return activeTerrain;
				}
			}
			for (int i = 0; i < Terrain.activeTerrains.Length; i++)
			{
				activeTerrain = Terrain.activeTerrains[i];
				Vector3 position2 = activeTerrain.GetPosition();
				Vector3 vector2 = position2 + activeTerrain.terrainData.size;
				if (locationWU.x >= position2.x && locationWU.x <= vector2.x && locationWU.z >= position2.z && locationWU.z <= vector2.z)
				{
					return activeTerrain;
				}
			}
			return null;
		}

		private Vector3 GetLocalPosition(Terrain terrain, Vector3 locationWU)
		{
			Vector3 vector = terrain.transform.InverseTransformPoint(locationWU);
			return new Vector3(Mathf.InverseLerp(0f, terrain.terrainData.size.x, vector.x), Mathf.InverseLerp(0f, terrain.terrainData.size.y, vector.y), Mathf.InverseLerp(0f, terrain.terrainData.size.z, vector.z));
		}

		private float[,,] GetTexturesAtLocation(Terrain terrain, Vector3 locationTU)
		{
			return terrain.terrainData.GetAlphamaps((int)(locationTU.x * (float)(terrain.terrainData.alphamapWidth - 1)), (int)(locationTU.z * (float)(terrain.terrainData.alphamapHeight - 1)), 1, 1);
		}

		private Vector3 GetNormalsAtLocation(Terrain terrain, Vector3 locationTU)
		{
			return terrain.terrainData.GetInterpolatedNormal(locationTU.x, locationTU.z);
		}
	}
}