using System;
using System.Collections;
using System.Collections.Generic;
using LE_LevelEditor.Commands;
using LE_LevelEditor.Events;
using LE_LevelEditor.UI;
using UndoRedo;
using UnityEngine;

namespace LE_LevelEditor.Logic
{
	public class LE_LogicTerrain : LE_LogicBase
	{
		private LE_ConfigTerrain m_confT;

		public LE_GUI3dTerrain m_GUI3dTerrain;

		private TerrainData m_terrainDataToCreate = new TerrainData();

		private bool m_doCreateTerrain;

		private bool m_doRebuildTerrainTab;

		private int m_selectedTextureIndex;

		private int m_selectedBrushIndex;

		private bool m_isHeightRaise = true;

		public LE_LogicTerrain(LE_ConfigTerrain p_confTerrain, LE_GUI3dTerrain p_GUI3dTerrain)
		{
			m_confT = p_confTerrain;
			m_GUI3dTerrain = p_GUI3dTerrain;
			m_GUI3dTerrain.TERRAIN_LAYER = p_confTerrain.TerrainLayer;
			if (p_confTerrain.BrushProjector != null)
			{
				m_GUI3dTerrain.BrushProjector = p_confTerrain.BrushProjector;
			}
			else
			{
				Debug.LogError("LE_GUILogicTerrain: LE_ConfigTerrain.BrushProjector was not initialized! You need to set it in the inspector.");
			}
			if (p_confTerrain.Brushes.Length > 0)
			{
				m_GUI3dTerrain.BrushAlphaTexture = p_confTerrain.Brushes[0];
			}
			else
			{
				Debug.LogError("LE_GUILogicTerrain: LE_ConfigTerrain.Brushes was not initialized! You need to set it in the inspector.");
			}
			CheckParameters();
			InitTerrainValues();
			LE_EventInterface.OnLoadedLevelInEditor = (EventHandler<EventArgs>)Delegate.Combine(LE_EventInterface.OnLoadedLevelInEditor, new EventHandler<EventArgs>(OnLoadedLevelInEditor));
			LE_GUIInterface.EventHandlers events = LE_GUIInterface.Instance.events;
			events.OnTerrainWidthChanged = (EventHandler<LE_GUIInterface.EventHandlers.StringEventArgs>)Delegate.Combine(events.OnTerrainWidthChanged, new EventHandler<LE_GUIInterface.EventHandlers.StringEventArgs>(OnTerrainWidthChanged));
			LE_GUIInterface.EventHandlers events2 = LE_GUIInterface.Instance.events;
			events2.OnTerrainLengthChanged = (EventHandler<LE_GUIInterface.EventHandlers.StringEventArgs>)Delegate.Combine(events2.OnTerrainLengthChanged, new EventHandler<LE_GUIInterface.EventHandlers.StringEventArgs>(OnTerrainLengthChanged));
			LE_GUIInterface.EventHandlers events3 = LE_GUIInterface.Instance.events;
			events3.OnTerrainHeightChanged = (EventHandler<LE_GUIInterface.EventHandlers.StringEventArgs>)Delegate.Combine(events3.OnTerrainHeightChanged, new EventHandler<LE_GUIInterface.EventHandlers.StringEventArgs>(OnTerrainHeightChanged));
			LE_GUIInterface.EventHandlers events4 = LE_GUIInterface.Instance.events;
			events4.OnTerrainBaseTextureChanged = (EventHandler<LE_GUIInterface.EventHandlers.IntEventArgs>)Delegate.Combine(events4.OnTerrainBaseTextureChanged, new EventHandler<LE_GUIInterface.EventHandlers.IntEventArgs>(OnTerrainBaseTextureChanged));
			LE_GUIInterface.EventHandlers events5 = LE_GUIInterface.Instance.events;
			events5.OnTerrainBrushChanged = (EventHandler<LE_GUIInterface.EventHandlers.IntEventArgs>)Delegate.Combine(events5.OnTerrainBrushChanged, new EventHandler<LE_GUIInterface.EventHandlers.IntEventArgs>(OnTerrainBrushChanged));
			LE_GUIInterface.EventHandlers events6 = LE_GUIInterface.Instance.events;
			events6.OnTerrainPaintTextureChanged = (EventHandler<LE_GUIInterface.EventHandlers.IntEventArgs>)Delegate.Combine(events6.OnTerrainPaintTextureChanged, new EventHandler<LE_GUIInterface.EventHandlers.IntEventArgs>(OnTerrainPaintTextureChanged));
			LE_GUIInterface.EventHandlers events7 = LE_GUIInterface.Instance.events;
			events7.OnTerrainPaintTextureAdded = (EventHandler<LE_GUIInterface.EventHandlers.TextureEventArgs>)Delegate.Combine(events7.OnTerrainPaintTextureAdded, new EventHandler<LE_GUIInterface.EventHandlers.TextureEventArgs>(OnTerrainPaintTextureAdded));
			LE_GUIInterface.EventHandlers events8 = LE_GUIInterface.Instance.events;
			events8.OnTerrainEditBrushSizeChanged = (EventHandler<LE_GUIInterface.EventHandlers.FloatEventArgs>)Delegate.Combine(events8.OnTerrainEditBrushSizeChanged, new EventHandler<LE_GUIInterface.EventHandlers.FloatEventArgs>(OnTerrainEditBrushSizeChanged));
			LE_GUIInterface.EventHandlers events9 = LE_GUIInterface.Instance.events;
			events9.OnTerrainEditBrushAmountChanged = (EventHandler<LE_GUIInterface.EventHandlers.FloatEventArgs>)Delegate.Combine(events9.OnTerrainEditBrushAmountChanged, new EventHandler<LE_GUIInterface.EventHandlers.FloatEventArgs>(OnTerrainEditBrushAmountChanged));
			LE_GUIInterface.EventHandlers events10 = LE_GUIInterface.Instance.events;
			events10.OnTerrainEditBrushTargetValueChanged = (EventHandler<LE_GUIInterface.EventHandlers.FloatEventArgs>)Delegate.Combine(events10.OnTerrainEditBrushTargetValueChanged, new EventHandler<LE_GUIInterface.EventHandlers.FloatEventArgs>(OnTerrainEditBrushTargetValueChanged));
			LE_GUIInterface.EventHandlers events11 = LE_GUIInterface.Instance.events;
			events11.OnTerrainEditBrushTextureTargetValueChanged = (EventHandler<LE_GUIInterface.EventHandlers.FloatEventArgs>)Delegate.Combine(events11.OnTerrainEditBrushTextureTargetValueChanged, new EventHandler<LE_GUIInterface.EventHandlers.FloatEventArgs>(OnTerrainEditBrushTextureTargetValueChanged));
			LE_GUIInterface.EventHandlers events12 = LE_GUIInterface.Instance.events;
			events12.OnTerrainEditDirectionChanged = (EventHandler<LE_GUIInterface.EventHandlers.FloatEventArgs>)Delegate.Combine(events12.OnTerrainEditDirectionChanged, new EventHandler<LE_GUIInterface.EventHandlers.FloatEventArgs>(OnTerrainEditDirectionChanged));
			LE_GUIInterface.EventHandlers events13 = LE_GUIInterface.Instance.events;
			events13.OnTerrainChangeHeightModeChanged = (EventHandler<LE_GUIInterface.EventHandlers.TerrainChangeHeightModeEventArgs>)Delegate.Combine(events13.OnTerrainChangeHeightModeChanged, new EventHandler<LE_GUIInterface.EventHandlers.TerrainChangeHeightModeEventArgs>(OnTerrainChangeHeightModeChanged));
			LE_GUIInterface.EventHandlers events14 = LE_GUIInterface.Instance.events;
			events14.OnTerrainIsDirectedSmoothChanged = (EventHandler<LE_GUIInterface.EventHandlers.BoolEventArgs>)Delegate.Combine(events14.OnTerrainIsDirectedSmoothChanged, new EventHandler<LE_GUIInterface.EventHandlers.BoolEventArgs>(OnTerrainIsDirectedSmoothChanged));
			LE_GUIInterface.EventHandlers events15 = LE_GUIInterface.Instance.events;
			events15.OnTerrainCreateBtn = (System.EventHandler)Delegate.Combine(events15.OnTerrainCreateBtn, new System.EventHandler(OnTerrainCreateBtn));
			LE_GUIInterface.EventHandlers events16 = LE_GUIInterface.Instance.events;
			events16.OnTerrainEditModeBtn = (EventHandler<LE_GUIInterface.EventHandlers.TerrainEditModeEventArgs>)Delegate.Combine(events16.OnTerrainEditModeBtn, new EventHandler<LE_GUIInterface.EventHandlers.TerrainEditModeEventArgs>(OnTerrainEditModeBtn));
			LE_GUIInterface.EventHandlers events17 = LE_GUIInterface.Instance.events;
			events17.OnTerrainReadPaintHeightBtn = (System.EventHandler)Delegate.Combine(events17.OnTerrainReadPaintHeightBtn, new System.EventHandler(OnTerrainReadPaintHeightBtn));
		}

		public override void Destroy()
		{
			LE_EventInterface.OnLoadedLevelInEditor = (EventHandler<EventArgs>)Delegate.Remove(LE_EventInterface.OnLoadedLevelInEditor, new EventHandler<EventArgs>(OnLoadedLevelInEditor));
			if (LE_GUIInterface.Instance != null)
			{
				LE_GUIInterface.EventHandlers events = LE_GUIInterface.Instance.events;
				events.OnTerrainWidthChanged = (EventHandler<LE_GUIInterface.EventHandlers.StringEventArgs>)Delegate.Remove(events.OnTerrainWidthChanged, new EventHandler<LE_GUIInterface.EventHandlers.StringEventArgs>(OnTerrainWidthChanged));
				LE_GUIInterface.EventHandlers events2 = LE_GUIInterface.Instance.events;
				events2.OnTerrainLengthChanged = (EventHandler<LE_GUIInterface.EventHandlers.StringEventArgs>)Delegate.Remove(events2.OnTerrainLengthChanged, new EventHandler<LE_GUIInterface.EventHandlers.StringEventArgs>(OnTerrainLengthChanged));
				LE_GUIInterface.EventHandlers events3 = LE_GUIInterface.Instance.events;
				events3.OnTerrainHeightChanged = (EventHandler<LE_GUIInterface.EventHandlers.StringEventArgs>)Delegate.Remove(events3.OnTerrainHeightChanged, new EventHandler<LE_GUIInterface.EventHandlers.StringEventArgs>(OnTerrainHeightChanged));
				LE_GUIInterface.EventHandlers events4 = LE_GUIInterface.Instance.events;
				events4.OnTerrainBaseTextureChanged = (EventHandler<LE_GUIInterface.EventHandlers.IntEventArgs>)Delegate.Remove(events4.OnTerrainBaseTextureChanged, new EventHandler<LE_GUIInterface.EventHandlers.IntEventArgs>(OnTerrainBaseTextureChanged));
				LE_GUIInterface.EventHandlers events5 = LE_GUIInterface.Instance.events;
				events5.OnTerrainBrushChanged = (EventHandler<LE_GUIInterface.EventHandlers.IntEventArgs>)Delegate.Remove(events5.OnTerrainBrushChanged, new EventHandler<LE_GUIInterface.EventHandlers.IntEventArgs>(OnTerrainBrushChanged));
				LE_GUIInterface.EventHandlers events6 = LE_GUIInterface.Instance.events;
				events6.OnTerrainPaintTextureChanged = (EventHandler<LE_GUIInterface.EventHandlers.IntEventArgs>)Delegate.Remove(events6.OnTerrainPaintTextureChanged, new EventHandler<LE_GUIInterface.EventHandlers.IntEventArgs>(OnTerrainPaintTextureChanged));
				LE_GUIInterface.EventHandlers events7 = LE_GUIInterface.Instance.events;
				events7.OnTerrainPaintTextureAdded = (EventHandler<LE_GUIInterface.EventHandlers.TextureEventArgs>)Delegate.Remove(events7.OnTerrainPaintTextureAdded, new EventHandler<LE_GUIInterface.EventHandlers.TextureEventArgs>(OnTerrainPaintTextureAdded));
				LE_GUIInterface.EventHandlers events8 = LE_GUIInterface.Instance.events;
				events8.OnTerrainEditBrushSizeChanged = (EventHandler<LE_GUIInterface.EventHandlers.FloatEventArgs>)Delegate.Remove(events8.OnTerrainEditBrushSizeChanged, new EventHandler<LE_GUIInterface.EventHandlers.FloatEventArgs>(OnTerrainEditBrushSizeChanged));
				LE_GUIInterface.EventHandlers events9 = LE_GUIInterface.Instance.events;
				events9.OnTerrainEditBrushAmountChanged = (EventHandler<LE_GUIInterface.EventHandlers.FloatEventArgs>)Delegate.Remove(events9.OnTerrainEditBrushAmountChanged, new EventHandler<LE_GUIInterface.EventHandlers.FloatEventArgs>(OnTerrainEditBrushAmountChanged));
				LE_GUIInterface.EventHandlers events10 = LE_GUIInterface.Instance.events;
				events10.OnTerrainEditBrushTargetValueChanged = (EventHandler<LE_GUIInterface.EventHandlers.FloatEventArgs>)Delegate.Remove(events10.OnTerrainEditBrushTargetValueChanged, new EventHandler<LE_GUIInterface.EventHandlers.FloatEventArgs>(OnTerrainEditBrushTargetValueChanged));
				LE_GUIInterface.EventHandlers events11 = LE_GUIInterface.Instance.events;
				events11.OnTerrainEditBrushTextureTargetValueChanged = (EventHandler<LE_GUIInterface.EventHandlers.FloatEventArgs>)Delegate.Remove(events11.OnTerrainEditBrushTextureTargetValueChanged, new EventHandler<LE_GUIInterface.EventHandlers.FloatEventArgs>(OnTerrainEditBrushTextureTargetValueChanged));
				LE_GUIInterface.EventHandlers events12 = LE_GUIInterface.Instance.events;
				events12.OnTerrainEditDirectionChanged = (EventHandler<LE_GUIInterface.EventHandlers.FloatEventArgs>)Delegate.Remove(events12.OnTerrainEditDirectionChanged, new EventHandler<LE_GUIInterface.EventHandlers.FloatEventArgs>(OnTerrainEditDirectionChanged));
				LE_GUIInterface.EventHandlers events13 = LE_GUIInterface.Instance.events;
				events13.OnTerrainChangeHeightModeChanged = (EventHandler<LE_GUIInterface.EventHandlers.TerrainChangeHeightModeEventArgs>)Delegate.Remove(events13.OnTerrainChangeHeightModeChanged, new EventHandler<LE_GUIInterface.EventHandlers.TerrainChangeHeightModeEventArgs>(OnTerrainChangeHeightModeChanged));
				LE_GUIInterface.EventHandlers events14 = LE_GUIInterface.Instance.events;
				events14.OnTerrainIsDirectedSmoothChanged = (EventHandler<LE_GUIInterface.EventHandlers.BoolEventArgs>)Delegate.Remove(events14.OnTerrainIsDirectedSmoothChanged, new EventHandler<LE_GUIInterface.EventHandlers.BoolEventArgs>(OnTerrainIsDirectedSmoothChanged));
				LE_GUIInterface.EventHandlers events15 = LE_GUIInterface.Instance.events;
				events15.OnTerrainCreateBtn = (System.EventHandler)Delegate.Remove(events15.OnTerrainCreateBtn, new System.EventHandler(OnTerrainCreateBtn));
				LE_GUIInterface.EventHandlers events16 = LE_GUIInterface.Instance.events;
				events16.OnTerrainEditModeBtn = (EventHandler<LE_GUIInterface.EventHandlers.TerrainEditModeEventArgs>)Delegate.Remove(events16.OnTerrainEditModeBtn, new EventHandler<LE_GUIInterface.EventHandlers.TerrainEditModeEventArgs>(OnTerrainEditModeBtn));
				LE_GUIInterface.EventHandlers events17 = LE_GUIInterface.Instance.events;
				events17.OnTerrainReadPaintHeightBtn = (System.EventHandler)Delegate.Remove(events17.OnTerrainReadPaintHeightBtn, new System.EventHandler(OnTerrainReadPaintHeightBtn));
			}
		}

		public override void Update()
		{
			if (m_doCreateTerrain && m_terrainDataToCreate != null)
			{
				m_doCreateTerrain = false;
				UR_CommandMgr.Instance.Execute(new LE_CmdCreateTerrain(this, m_selectedTextureIndex, m_terrainDataToCreate));
				m_terrainDataToCreate = null;
			}
			if (m_doRebuildTerrainTab)
			{
				m_doRebuildTerrainTab = false;
				InitTerrainValues();
			}
		}

		public void CreateOrRecycleTerrainWithUIUpdate(TerrainData p_terrainData, int p_terrainBaseTextureIndex)
		{
			CreateOrRecycleTerrain(p_terrainData, m_GUI3dTerrain.TERRAIN_LAYER, m_confT, p_terrainBaseTextureIndex);
			m_terrainDataToCreate = null;
			m_doRebuildTerrainTab = true;
			SetTerrainUIMode(LE_GUIInterface.Delegates.ETerrainUIMode.EDIT);
		}

		public void DestroyOrResetTerrainWithUIUpdate()
		{
			DestroyOrResetTerrain();
			m_terrainDataToCreate = new TerrainData();
			m_doRebuildTerrainTab = true;
			SetTerrainUIMode(LE_GUIInterface.Delegates.ETerrainUIMode.CREATE);
		}

		public void AddTerrainTexture(Texture2D p_texture)
		{
			if (m_confT.TerrainTextureConfig != null)
			{
				if (!(m_GUI3dTerrain != null) || m_GUI3dTerrain.TerrainManager == null || !(m_GUI3dTerrain.TerrainManager.TerrainData != null))
				{
					return;
				}
				SplatPrototype[] splatPrototypes = m_GUI3dTerrain.TerrainManager.TerrainData.splatPrototypes;
				SplatPrototype[] array = new SplatPrototype[splatPrototypes.Length + 1];
				Array.Copy(splatPrototypes, array, splatPrototypes.Length);
				int textureIndex = GetTextureIndex(p_texture);
				if (textureIndex >= 0)
				{
					array[array.Length - 1] = new SplatPrototype();
					array[array.Length - 1].texture = m_confT.TerrainTextureConfig.TERRAIN_TEXTURES[textureIndex];
					array[array.Length - 1].normalMap = m_confT.TerrainTextureConfig.TERRAIN_NORMALS[textureIndex];
					array[array.Length - 1].tileSize = m_confT.TerrainTextureConfig.TERRAIN_TEXTURE_SIZES[textureIndex];
					array[array.Length - 1].tileOffset = m_confT.TerrainTextureConfig.TERRAIN_TEXTURE_OFFSETS[textureIndex];
					m_GUI3dTerrain.TerrainManager.TerrainData.splatPrototypes = array;
					m_doRebuildTerrainTab = true;
					if (LE_EventInterface.OnChangeLevelData != null)
					{
						LE_EventInterface.OnChangeLevelData(this, new LE_LevelDataChangedEvent(LE_ELevelDataChangeType.TERRAIN_TEXTURES));
					}
				}
				else
				{
					Debug.LogError("LE_LogicTerrain: AddTerrainTexture: could not find given texture in TerrainTextureConfig!");
				}
			}
			else
			{
				Debug.LogError("LE_LogicTerrain: AddTerrainTexture: LE_ConfigTerrain has no TerrainTextureConfig set!");
			}
		}

		public void RemoveTerrainTexture(Texture2D p_texture)
		{
			if (m_confT.TerrainTextureConfig != null)
			{
				if (!(m_GUI3dTerrain != null) || m_GUI3dTerrain.TerrainManager == null || !(m_GUI3dTerrain.TerrainManager.TerrainData != null))
				{
					return;
				}
				SplatPrototype[] splatPrototypes = m_GUI3dTerrain.TerrainManager.TerrainData.splatPrototypes;
				if (splatPrototypes.Length > 0)
				{
					bool flag = false;
					SplatPrototype[] array = new SplatPrototype[splatPrototypes.Length - 1];
					for (int i = 0; i < splatPrototypes.Length; i++)
					{
						if (!flag && splatPrototypes[i] != null && splatPrototypes[i].texture == p_texture)
						{
							flag = true;
						}
						else
						{
							array[(!flag) ? i : (i - 1)] = splatPrototypes[i];
						}
					}
					if (flag)
					{
						m_GUI3dTerrain.TerrainManager.TerrainData.splatPrototypes = array;
						m_doRebuildTerrainTab = true;
						if (LE_EventInterface.OnChangeLevelData != null)
						{
							LE_EventInterface.OnChangeLevelData(this, new LE_LevelDataChangedEvent(LE_ELevelDataChangeType.TERRAIN_TEXTURES));
						}
					}
					else
					{
						Debug.LogError("LE_LogicTerrain: RemoveTerrainTexture: given texture is not a splat texture of the terrain!");
					}
				}
				else
				{
					Debug.LogError("LE_LogicTerrain: RemoveTerrainTexture: terrain has no splat textures set!");
				}
			}
			else
			{
				Debug.LogError("LE_LogicTerrain: RemoveTerrainTexture: LE_ConfigTerrain has no TerrainTextureConfig set!");
			}
		}

		public static GameObject CreateOrRecycleTerrain(TerrainData p_terrainData, int p_terrainLayer)
		{
			LE_GUI3dTerrain lE_GUI3dTerrain = UnityEngine.Object.FindObjectOfType<LE_GUI3dTerrain>();
			Terrain terrain = ((!(lE_GUI3dTerrain != null)) ? null : lE_GUI3dTerrain.TerrainInstance);
			GameObject gameObject;
			if (terrain != null)
			{
				gameObject = terrain.gameObject;
				lE_GUI3dTerrain.RecycleTerrain(p_terrainData, true);
			}
			else
			{
				gameObject = Terrain.CreateTerrainGameObject(p_terrainData);
				if (lE_GUI3dTerrain != null)
				{
					lE_GUI3dTerrain.SetTerrain(gameObject.GetComponent<Terrain>());
				}
			}
			gameObject.layer = p_terrainLayer;
			gameObject.transform.position = new Vector3((0f - p_terrainData.size.x) * 0.5f, -2f, (0f - p_terrainData.size.z) * 0.5f);
			return gameObject;
		}

		public static void DestroyOrResetTerrain()
		{
			LE_GUI3dTerrain lE_GUI3dTerrain = UnityEngine.Object.FindObjectOfType<LE_GUI3dTerrain>();
			if (lE_GUI3dTerrain != null)
			{
				lE_GUI3dTerrain.ResetToDefaultOrDestroyTerrain();
			}
		}

		private static void CreateOrRecycleTerrain(TerrainData p_terrainData, int p_terrainLayer, LE_ConfigTerrain p_confT, int p_terrainBaseTextureIndex)
		{
			if (p_terrainData == null)
			{
				Debug.LogError("LE_LogicTerrain: CreateOrRecycleTerrain: passed terrain data was null!");
				return;
			}
			Vector3 size = p_terrainData.size;
			float num = Mathf.Max(size.x, size.z);
			int heightmapResolution = p_confT.HeightmapResolutions[0];
			for (int i = 1; i < p_confT.HeightmapResolutionSizes.Length && num >= p_confT.HeightmapResolutionSizes[i - 1]; i++)
			{
				heightmapResolution = p_confT.HeightmapResolutions[i];
			}
			p_terrainData.heightmapResolution = heightmapResolution;
			int alphamapResolution = p_confT.AlphamapResolutions[0];
			for (int j = 1; j < p_confT.AlphamapResolutionSizes.Length && num >= p_confT.AlphamapResolutionSizes[j - 1]; j++)
			{
				alphamapResolution = p_confT.AlphamapResolutions[j];
			}
			p_terrainData.alphamapResolution = alphamapResolution;
			p_terrainData.size = size;
			SplatPrototype[] array = new SplatPrototype[1]
			{
				new SplatPrototype()
			};
			array[0].texture = p_confT.TerrainTextureConfig.TERRAIN_TEXTURES[p_terrainBaseTextureIndex];
			array[0].normalMap = p_confT.TerrainTextureConfig.TERRAIN_NORMALS[p_terrainBaseTextureIndex];
			array[0].tileSize = p_confT.TerrainTextureConfig.TERRAIN_TEXTURE_SIZES[p_terrainBaseTextureIndex];
			array[0].tileOffset = p_confT.TerrainTextureConfig.TERRAIN_TEXTURE_OFFSETS[p_terrainBaseTextureIndex];
			p_terrainData.splatPrototypes = array;
			GameObject gameObject = CreateOrRecycleTerrain(p_terrainData, p_terrainLayer);
			if (LE_EventInterface.OnTerrainCreated != null)
			{
				LE_EventInterface.OnTerrainCreated(gameObject, new LE_TerrainCreatedEvent(gameObject));
			}
		}

		private static void SetTerrainUIMode(LE_GUIInterface.Delegates.ETerrainUIMode p_uiMode)
		{
			if (LE_GUIInterface.Instance.delegates.SetTerrainUIMode != null)
			{
				LE_GUIInterface.Instance.delegates.SetTerrainUIMode(p_uiMode);
			}
			else
			{
				Debug.LogWarning("LE_LogicTerrain: SetTerrainUIMode: you have not set the LE_GUIInterface.delegates.SetTerrainUIMode delegate. You need to set it for example if you want to disable the create UI after terrain creation!");
			}
		}

		private void OnLoadedLevelInEditor(object p_obj, EventArgs p_args)
		{
			LE_GUIInterface.Delegates.ETerrainUIMode terrainUIMode = GetTerrainUIMode();
			if (terrainUIMode == LE_GUIInterface.Delegates.ETerrainUIMode.CREATE)
			{
				m_terrainDataToCreate = new TerrainData();
			}
			else
			{
				m_terrainDataToCreate = null;
			}
			if (LE_GUIInterface.Instance.delegates.SetTerrainUIMode != null)
			{
				LE_GUIInterface.Instance.delegates.SetTerrainUIMode(terrainUIMode);
			}
			else
			{
				Debug.LogWarning("LE_LogicTerrain: you have not set the LE_GUIInterface.delegates.SetTerrainUIMode delegate. Set it to show the create UI if the loaded level has no terrain and the edit UI if the loaded level has a terrain!");
			}
			m_doRebuildTerrainTab = true;
		}

		private void OnTerrainWidthChanged(object p_obj, LE_GUIInterface.EventHandlers.StringEventArgs p_args)
		{
			int result;
			if (int.TryParse(p_args.Value, out result))
			{
				result = Mathf.Max(32, result);
				if (m_terrainDataToCreate != null)
				{
					m_terrainDataToCreate.size = new Vector3(result, m_terrainDataToCreate.size.y, m_terrainDataToCreate.size.z);
				}
				else
				{
					m_GUI3dTerrain.TerrainManager.TerrainData.size = new Vector3(result, m_GUI3dTerrain.TerrainManager.TerrainData.size.y, m_GUI3dTerrain.TerrainManager.TerrainData.size.z);
				}
			}
		}

		private void OnTerrainLengthChanged(object p_obj, LE_GUIInterface.EventHandlers.StringEventArgs p_args)
		{
			int result;
			if (int.TryParse(p_args.Value, out result))
			{
				result = Mathf.Max(32, result);
				if (m_terrainDataToCreate != null)
				{
					m_terrainDataToCreate.size = new Vector3(m_terrainDataToCreate.size.x, m_terrainDataToCreate.size.y, result);
				}
				else
				{
					m_GUI3dTerrain.TerrainManager.TerrainData.size = new Vector3(m_GUI3dTerrain.TerrainManager.TerrainData.size.x, m_GUI3dTerrain.TerrainManager.TerrainData.size.y, result);
				}
			}
		}

		private void OnTerrainHeightChanged(object p_obj, LE_GUIInterface.EventHandlers.StringEventArgs p_args)
		{
			int result;
			if (int.TryParse(p_args.Value, out result))
			{
				result = Mathf.Max(32, result);
				if (m_terrainDataToCreate != null)
				{
					m_terrainDataToCreate.size = new Vector3(m_terrainDataToCreate.size.x, result, m_terrainDataToCreate.size.z);
				}
				else
				{
					m_GUI3dTerrain.TerrainManager.TerrainData.size = new Vector3(m_GUI3dTerrain.TerrainManager.TerrainData.size.x, result, m_GUI3dTerrain.TerrainManager.TerrainData.size.z);
				}
			}
		}

		private void OnTerrainBaseTextureChanged(object p_obj, LE_GUIInterface.EventHandlers.IntEventArgs p_args)
		{
			m_selectedTextureIndex = p_args.Value;
			if (m_terrainDataToCreate == null)
			{
				Debug.LogWarning("LE_LogicTerrain: OnTerrainBaseTextureChanged: terrain base texture cannot be changed after the terrain was created! If a terrain already exists then you have changed the terrain paint texture with this call.");
			}
		}

		private void OnTerrainBrushChanged(object p_obj, LE_GUIInterface.EventHandlers.IntEventArgs p_args)
		{
			m_selectedBrushIndex = p_args.Value;
			m_GUI3dTerrain.BrushAlphaTexture = m_confT.Brushes[m_selectedBrushIndex];
			m_GUI3dTerrain.SetCursorPosition(new Vector3(Screen.width / 2, Screen.height / 2, 0f));
		}

		private void OnTerrainPaintTextureChanged(object p_obj, LE_GUIInterface.EventHandlers.IntEventArgs p_args)
		{
			m_selectedTextureIndex = p_args.Value;
			m_GUI3dTerrain.SelectedSplatPrototype = m_selectedTextureIndex;
		}

		private void OnTerrainPaintTextureAdded(object p_obj, LE_GUIInterface.EventHandlers.TextureEventArgs p_args)
		{
			UR_CommandMgr.Instance.Execute(new LE_CmdAddTerrainTexture(this, p_args.Value));
		}

		private void OnTerrainEditBrushSizeChanged(object p_obj, LE_GUIInterface.EventHandlers.FloatEventArgs p_args)
		{
			float value = p_args.Value;
			value *= value;
			value = Mathf.Max(0.002f, value);
			m_GUI3dTerrain.Size = value;
			m_GUI3dTerrain.SetCursorPosition(new Vector3(Screen.width / 2, Screen.height / 2, 0f));
		}

		private void OnTerrainEditBrushAmountChanged(object p_obj, LE_GUIInterface.EventHandlers.FloatEventArgs p_args)
		{
			float value = p_args.Value;
			value = Mathf.Max(0.002f, value);
			m_GUI3dTerrain.Amount = ((!m_isHeightRaise) ? (0f - value) : value);
		}

		private void OnTerrainEditBrushTargetValueChanged(object p_obj, LE_GUIInterface.EventHandlers.FloatEventArgs p_args)
		{
			m_GUI3dTerrain.TargetRelativeValue = p_args.Value;
		}

		private void OnTerrainEditBrushTextureTargetValueChanged(object p_obj, LE_GUIInterface.EventHandlers.FloatEventArgs p_args)
		{
			m_GUI3dTerrain.TargetTextureStrengthValue = p_args.Value;
		}

		private void OnTerrainEditDirectionChanged(object p_obj, LE_GUIInterface.EventHandlers.FloatEventArgs p_args)
		{
			m_GUI3dTerrain.DirectedSmoothAngle = Mathf.Round(p_args.Value * 360f / 22.5f) * 22.5f;
			m_GUI3dTerrain.SetCursorPosition(new Vector3(Screen.width / 2, Screen.height / 2, 0f));
		}

		private void OnTerrainChangeHeightModeChanged(object p_obj, LE_GUIInterface.EventHandlers.TerrainChangeHeightModeEventArgs p_args)
		{
			if (p_args.ChangeHeightMode == LE_GUIInterface.EventHandlers.ETerrainChangeHeightMode.RAISE)
			{
				m_isHeightRaise = true;
				m_GUI3dTerrain.Amount = Mathf.Abs(m_GUI3dTerrain.Amount);
			}
			else
			{
				m_isHeightRaise = false;
				m_GUI3dTerrain.Amount = 0f - Mathf.Abs(m_GUI3dTerrain.Amount);
			}
		}

		private void OnTerrainIsDirectedSmoothChanged(object p_obj, LE_GUIInterface.EventHandlers.BoolEventArgs p_args)
		{
			m_GUI3dTerrain.IsDirectedSmooth = p_args.Value;
			m_GUI3dTerrain.SetCursorPosition(new Vector3(Screen.width / 2, Screen.height / 2, 0f));
		}

		private void OnTerrainCreateBtn(object p_obj, EventArgs p_args)
		{
			m_doCreateTerrain = true;
			m_doRebuildTerrainTab = true;
		}

		private void OnTerrainEditModeBtn(object p_obj, LE_GUIInterface.EventHandlers.TerrainEditModeEventArgs p_args)
		{
			m_GUI3dTerrain.EditMode = p_args.EditMode;
		}

		private void OnTerrainReadPaintHeightBtn(object sender, EventArgs e)
		{
			if (LE_GUIInterface.Instance.delegates.SetTerrainIsReadingPaintHeight != null)
			{
				LE_GUIInterface.Instance.delegates.SetTerrainIsReadingPaintHeight(true);
			}
			else
			{
				Debug.LogWarning("LE_LogicTerrain: OnTerrainReadPaintHeightBtn: you have not set the LE_GUIInterface.delegates.SetTerrainIsReadingPaintHeight delegate. Set it if you want to give visual feedback to the user showing if the terrain paint height is currently being read!");
			}
			m_GUI3dTerrain.IsReadingTerrainPaintHeight = true;
			m_GUI3dTerrain.StartCoroutine(ReadPaintHeightRoutine());
		}

		private void CheckParameters()
		{
			if (string.IsNullOrEmpty(LayerMask.LayerToName(m_confT.TerrainLayer)))
			{
				Debug.LogWarning("LE_GUILogicTerrain: Inspector property 'LE_ConfigTerrain.TerrainLayer' is set to '" + m_confT.TerrainLayer + "', but this layer has no name in 'Tags & Layers' set. Please set the name of this layer to 'Terrain' or change the value of the 'LE_ConfigTerrain.TerrainLayer' property! To open the 'Tags & Layers' manager select any game object, in the inspector click on the layer drop down at top right then click on 'Add Layer...'.");
			}
			else if (LayerMask.LayerToName(m_confT.TerrainLayer) != "Terrain")
			{
				Debug.LogWarning("LE_GUILogicTerrain: Inspector property 'LE_ConfigTerrain.TerrainLayer' is set to '" + m_confT.TerrainLayer + "', but the name of this layer is '" + LayerMask.LayerToName(m_confT.TerrainLayer) + "'. Is this intended? If not please set the name of this layer to 'Terrain' or change the value of the 'LE_ConfigTerrain.TerrainLayer' property! To open the 'Tags & Layers' manager select any game object, in the inspector click on the layer drop down at top right then click on 'Add Layer...'.");
			}
			if (m_confT.HeightmapResolutions == null || m_confT.HeightmapResolutions.Length == 0)
			{
				Debug.LogError("LE_GUILogicTerrain: LE_ConfigTerrain: TerrainHeightmapResolutions is null or empty! Add supported heightmap resolutions e.g. {65, 129, 257, 513} etc.");
			}
			else if (m_confT.HeightmapResolutionSizes == null || m_confT.HeightmapResolutionSizes.Length == 0)
			{
				Debug.LogError("LE_GUILogicTerrain: LE_ConfigTerrain: TerrainHeightmapResolutionSizes is null or empty! Add the terrain size thresholds that define which of the supported heightmap resolutions is used e.g. TerrainHeightmapResolutions = {65, 129, 257, 513} and TerrainHeightmapResolutionSizes = {125, 250, 500, 9999} etc.");
			}
			else if (m_confT.HeightmapResolutions.Length != m_confT.HeightmapResolutionSizes.Length)
			{
				Debug.LogError("LE_GUILogicTerrain: LE_ConfigTerrain: TerrainHeightmapResolutions and TerrainHeightmapResolutionSizes must have the same length!");
			}
			if (m_confT.AlphamapResolutions == null || m_confT.AlphamapResolutions.Length == 0)
			{
				Debug.LogError("LE_GUILogicTerrain: LE_ConfigTerrain: TerrainAlphamapResolutions is null or empty! Add supported alphamap resolutions e.g. {64, 128, 256, 512} etc.");
			}
			else if (m_confT.AlphamapResolutionSizes == null || m_confT.AlphamapResolutionSizes.Length == 0)
			{
				Debug.LogError("LE_GUILogicTerrain: LE_ConfigTerrain: TerrainAlphamapResolutionSizes is null or empty! Add the terrain size thresholds that define which of the supported alphamap resolutions is used e.g. TerrainAlphamapResolutions = {64, 128, 256, 512} and TerrainAlphamapResolutionSizes = {125, 250, 500, 9999} etc.");
			}
			else if (m_confT.AlphamapResolutions.Length != m_confT.AlphamapResolutionSizes.Length)
			{
				Debug.LogError("LE_GUILogicTerrain: LE_ConfigTerrain: TerrainAlphamapResolutions and TerrainAlphamapResolutionSizes must have the same length!");
			}
		}

		private void InitTerrainValues()
		{
			int num;
			int num2;
			int num3;
			if (m_terrainDataToCreate != null)
			{
				num = m_confT.InitialWidth;
				num2 = m_confT.InitialLength;
				num3 = m_confT.InitialHeight;
				m_terrainDataToCreate.size = new Vector3(num, num3, num2);
			}
			else
			{
				num = (int)m_GUI3dTerrain.TerrainManager.TerrainData.size.x;
				num2 = (int)m_GUI3dTerrain.TerrainManager.TerrainData.size.z;
				num3 = (int)m_GUI3dTerrain.TerrainManager.TerrainData.size.y;
			}
			string format = "LE_GUILogicTerrain: InitTerrainValues: you have not provided {0} delegate. If you show the terrain size values then the real terrain size might be different than shown in your UI!";
			if (LE_GUIInterface.Instance.delegates.SetTerrainWidth != null)
			{
				LE_GUIInterface.Instance.delegates.SetTerrainWidth(num);
			}
			else
			{
				Debug.LogWarning(string.Format(format, "LE_GUIInterface.delegates.SetTerrainWidth"));
			}
			if (LE_GUIInterface.Instance.delegates.SetTerrainLength != null)
			{
				LE_GUIInterface.Instance.delegates.SetTerrainLength(num2);
			}
			else
			{
				Debug.LogWarning(string.Format(format, "LE_GUIInterface.delegates.SetTerrainLength"));
			}
			if (LE_GUIInterface.Instance.delegates.SetTerrainHeight != null)
			{
				LE_GUIInterface.Instance.delegates.SetTerrainHeight(num3);
			}
			else
			{
				Debug.LogWarning(string.Format(format, "LE_GUIInterface.delegates.SetTerrainHeight"));
			}
			m_selectedTextureIndex = 0;
			if (m_confT.IsBaseTextureSelection)
			{
				if (LE_GUIInterface.Instance.delegates.SetTerrainBaseTextures != null)
				{
					LE_GUIInterface.Instance.delegates.SetTerrainBaseTextures(m_confT.TerrainTextureConfig.TERRAIN_TEXTURES, m_selectedTextureIndex);
				}
				else
				{
					Debug.LogError("LE_GUILogicTerrain: InitTerrainValues: you have not provided the LE_GUIInterface.delegates.SetTerrainBaseTextures delegate. If you want to use LE_ConfigTerrain.IsBaseTextureSelection==true, then you must set this delegate to show and update the base texture selection in your UI!");
				}
			}
			m_selectedBrushIndex = 0;
			if (m_confT.Brushes.Length > 0)
			{
				m_GUI3dTerrain.BrushAlphaTexture = m_confT.Brushes[0];
			}
			if (LE_GUIInterface.Instance.delegates.SetTerrainBrushes != null)
			{
				LE_GUIInterface.Instance.delegates.SetTerrainBrushes(m_confT.Brushes, m_selectedBrushIndex);
			}
			else
			{
				Debug.LogError("LE_GUILogicTerrain: InitTerrainValues: you have not provided the LE_GUIInterface.delegates.SetTerrainBrushes delegate. You must set this delegate to show and update the brush texture selection in your UI!");
			}
			if (LE_GUIInterface.Instance.delegates.SetTerrainEditBrushSize != null)
			{
				LE_GUIInterface.Instance.delegates.SetTerrainEditBrushSize(Mathf.Sqrt(m_GUI3dTerrain.Size));
			}
			else
			{
				Debug.LogWarning("LE_GUILogicTerrain: InitTerrainValues: you have not provided the LE_GUIInterface.delegates.SetTerrainEditBrushSize delegate. If you have a brush size slider, then its value might be different from the value used by the level editor.");
			}
			if (LE_GUIInterface.Instance.delegates.SetTerrainEditBrushAmount != null)
			{
				LE_GUIInterface.Instance.delegates.SetTerrainEditBrushAmount(Mathf.Abs(m_GUI3dTerrain.Amount));
			}
			else
			{
				Debug.LogWarning("LE_GUILogicTerrain: InitTerrainValues: you have not provided the LE_GUIInterface.delegates.SetTerrainEditBrushAmount delegate. If you have a brush amount slider, then its value might be different from the value used by the level editor.");
			}
			if (LE_GUIInterface.Instance.delegates.SetTerrainEditBrushTargetValue != null)
			{
				LE_GUIInterface.Instance.delegates.SetTerrainEditBrushTargetValue(m_GUI3dTerrain.TargetRelativeValue);
				LE_GUIInterface.Instance.delegates.SetTerrainEditBrushTextureTargetValue(m_GUI3dTerrain.TargetTextureStrengthValue);
			}
			else
			{
				Debug.LogWarning("LE_GUILogicTerrain: InitTerrainValues: you have not provided the LE_GUIInterface.delegates.SetTerrainEditBrushTargetValue delegate. If you have a brush target value slider, then its value might be different from the value used by the level editor.");
			}
			Texture2D[] terrainPaintTextures = GetTerrainPaintTextures();
			bool flag = terrainPaintTextures.Length >= m_confT.TerrainTextureConfig.TERRAIN_TEXTURES.Length || terrainPaintTextures.Length >= m_confT.MaxTextureCount;
			m_selectedTextureIndex = Mathf.Max(0, terrainPaintTextures.Length - 1);
			m_GUI3dTerrain.SelectedSplatPrototype = m_selectedTextureIndex;
			if (LE_GUIInterface.Instance.delegates.SetTerrainPaintTextures != null)
			{
				LE_GUIInterface.Instance.delegates.SetTerrainPaintTextures(terrainPaintTextures, GetUnusedTerrainTextures(), m_selectedTextureIndex, !flag);
			}
			else
			{
				Debug.LogWarning("LE_LogicTerrain: InitTerrainValues: you have not set the LE_GUIInterface.delegates.SetTerrainPaintTextures delegate. You need to set it to visualize the available paint textures and allow the user to select one of them!");
			}
		}

		private LE_GUIInterface.Delegates.ETerrainUIMode GetTerrainUIMode()
		{
			if (m_GUI3dTerrain.TerrainManager != null)
			{
				return LE_GUIInterface.Delegates.ETerrainUIMode.EDIT;
			}
			return LE_GUIInterface.Delegates.ETerrainUIMode.CREATE;
		}

		private Texture2D[] GetTerrainPaintTextures()
		{
			if (m_GUI3dTerrain.TerrainManager != null && m_GUI3dTerrain.TerrainManager.TerrainData != null)
			{
				SplatPrototype[] splatPrototypes = m_GUI3dTerrain.TerrainManager.TerrainData.splatPrototypes;
				Texture2D[] array = new Texture2D[splatPrototypes.Length];
				for (int i = 0; i < splatPrototypes.Length; i++)
				{
					array[i] = splatPrototypes[i].texture;
				}
				return array;
			}
			return new Texture2D[0];
		}

		private int GetTextureIndex(Texture2D p_texture)
		{
			for (int i = 0; i < m_confT.TerrainTextureConfig.TERRAIN_TEXTURES.Length; i++)
			{
				if (p_texture == m_confT.TerrainTextureConfig.TERRAIN_TEXTURES[i])
				{
					return i;
				}
			}
			return -1;
		}

		private IEnumerator ReadPaintHeightRoutine()
		{
			WaitForEndOfFrame wait = new WaitForEndOfFrame();
			while (m_GUI3dTerrain.IsReadingTerrainPaintHeight)
			{
				if (LE_GUIInterface.Instance.delegates.SetTerrainEditBrushTargetValue != null)
				{
					LE_GUIInterface.Instance.delegates.SetTerrainEditBrushTargetValue(m_GUI3dTerrain.TargetRelativeValue);
				}
				yield return wait;
			}
			if (LE_GUIInterface.Instance.delegates.SetTerrainIsReadingPaintHeight != null)
			{
				LE_GUIInterface.Instance.delegates.SetTerrainIsReadingPaintHeight(false);
			}
			else
			{
				Debug.LogWarning("LE_LogicTerrain: OnTerrainReadPaintHeightBtn: you have not set the LE_GUIInterface.delegates.SetTerrainIsReadingPaintHeight delegate. Set it if you want to give visual feedback to the user showing if the terrain paint height is currently being read!");
			}
			if (LE_GUIInterface.Instance.delegates.SetTerrainEditBrushTargetValue != null)
			{
				LE_GUIInterface.Instance.delegates.SetTerrainEditBrushTargetValue(m_GUI3dTerrain.TargetRelativeValue);
			}
			else
			{
				Debug.LogWarning("LE_GUILogicTerrain: ReadPaintHeightRoutine: you have not provided the LE_GUIInterface.delegates.SetTerrainEditBrushTargetValue delegate. If you have a brush target value slider, then its value is now different from the value used by the level editor, because the terrain paint height was read.");
			}
		}

		private Texture2D[] GetUnusedTerrainTextures()
		{
			if (m_confT.TerrainTextureConfig != null)
			{
				if (m_GUI3dTerrain != null && m_GUI3dTerrain.TerrainManager != null && m_GUI3dTerrain.TerrainManager.TerrainData != null)
				{
					Texture2D[] tERRAIN_TEXTURES = m_confT.TerrainTextureConfig.TERRAIN_TEXTURES;
					SplatPrototype[] splatPrototypes = m_GUI3dTerrain.TerrainManager.TerrainData.splatPrototypes;
					List<Texture2D> list = new List<Texture2D>();
					for (int i = 0; i < tERRAIN_TEXTURES.Length; i++)
					{
						bool flag = false;
						for (int j = 0; j < splatPrototypes.Length; j++)
						{
							if (splatPrototypes[j].texture == tERRAIN_TEXTURES[i])
							{
								flag = true;
								break;
							}
						}
						if (!flag)
						{
							list.Add(tERRAIN_TEXTURES[i]);
						}
					}
					return list.ToArray();
				}
				return m_confT.TerrainTextureConfig.TERRAIN_TEXTURES;
			}
			Debug.LogError("LE_LogicTerrain: GetUnusedTerrainTextures: LE_ConfigTerrain has no TerrainTextureConfig set!");
			return new Texture2D[0];
		}
	}
}