using UnityEngine;

[AddComponentMenu("Relief Terrain/Geometry Blend")]
[SelectionBase]
[RequireComponent(typeof(MeshFilter))]
public class GeometryVsTerrainBlend : MonoBehaviour
{
	public double UpdTim;

	private int progress_count_max;

	private int progress_count_current;

	private const int progress_granulation = 1000;

	private string progress_description = string.Empty;

	public float blend_distance = 0.1f;

	public GameObject blendedObject;

	public bool VoxelBlendedObject;

	public float _DeferredBlendGloss = 0.8f;

	[HideInInspector]
	public bool undo_flag;

	[HideInInspector]
	public bool paint_flag;

	[HideInInspector]
	public int paint_mode;

	[HideInInspector]
	public float paint_size = 0.5f;

	[HideInInspector]
	public float paint_smoothness;

	[HideInInspector]
	public float paint_opacity = 1f;

	[HideInInspector]
	public RTPColorChannels vertex_paint_channel = RTPColorChannels.A;

	[HideInInspector]
	public int addTrisSubdivision;

	[HideInInspector]
	public float addTrisMinAngle;

	[HideInInspector]
	public float addTrisMaxAngle = 90f;

	private Vector3[] paint_vertices;

	private Vector3[] paint_normals;

	private int[] paint_tris;

	private Transform underlying_transform;

	private MeshRenderer underlying_renderer;

	[HideInInspector]
	public RaycastHit paintHitInfo;

	[HideInInspector]
	public bool paintHitInfo_flag;

	[HideInInspector]
	private Texture2D tmp_globalColorMap;

	[HideInInspector]
	public Vector3[] normals_orig;

	[HideInInspector]
	public Vector4[] tangents_orig;

	[HideInInspector]
	public bool baked_normals;

	[HideInInspector]
	public Mesh orig_mesh;

	[HideInInspector]
	public Mesh pmesh;

	[HideInInspector]
	public bool shader_global_blend_capabilities;

	[HideInInspector]
	public float StickOffset = 0.03f;

	[HideInInspector]
	public bool Sticked;

	[HideInInspector]
	public bool StickedOptimized = true;

	[HideInInspector]
	public bool ModifyTris;

	[HideInInspector]
	public bool BuildMeshFlag;

	[HideInInspector]
	public bool RealizePaint_Flag;

	[HideInInspector]
	public string save_path = string.Empty;

	[HideInInspector]
	public bool isBatched;

	private Renderer _renderer;

	private void Start()
	{
		SetupValues();
	}

	private void GetRenderer()
	{
		if (!_renderer)
		{
			_renderer = GetComponent<Renderer>();
		}
	}

	public void SetupValues()
	{
		if (!blendedObject || (!(blendedObject.GetComponent(typeof(MeshRenderer)) != null) && !(blendedObject.GetComponent(typeof(Terrain)) != null)))
		{
			return;
		}
		if (underlying_transform == null)
		{
			underlying_transform = base.transform.Find("RTP_blend_underlying");
		}
		if (underlying_transform != null)
		{
			GameObject gameObject = underlying_transform.gameObject;
			underlying_renderer = (MeshRenderer)gameObject.GetComponent(typeof(MeshRenderer));
		}
		if (!(underlying_renderer != null) || !(underlying_renderer.sharedMaterial != null))
		{
			return;
		}
		ReliefTerrain reliefTerrain = (ReliefTerrain)blendedObject.GetComponent(typeof(ReliefTerrain));
		if ((bool)reliefTerrain)
		{
			Material sharedMaterial = underlying_renderer.sharedMaterial;
			reliefTerrain.RefreshTextures(sharedMaterial);
			reliefTerrain.globalSettingsHolder.Refresh(sharedMaterial);
			if (sharedMaterial.HasProperty("RTP_DeferredAddPassSpec"))
			{
				sharedMaterial.SetFloat("RTP_DeferredAddPassSpec", _DeferredBlendGloss);
			}
			if ((bool)reliefTerrain.controlA)
			{
				sharedMaterial.SetTexture("_Control", reliefTerrain.controlA);
			}
			if ((bool)reliefTerrain.ColorGlobal)
			{
				sharedMaterial.SetTexture("_Splat0", reliefTerrain.ColorGlobal);
			}
			if ((bool)reliefTerrain.NormalGlobal)
			{
				sharedMaterial.SetTexture("_Splat1", reliefTerrain.NormalGlobal);
			}
			if ((bool)reliefTerrain.TreesGlobal)
			{
				sharedMaterial.SetTexture("_Splat2", reliefTerrain.TreesGlobal);
			}
			if ((bool)reliefTerrain.BumpGlobalCombined)
			{
				sharedMaterial.SetTexture("_Splat3", reliefTerrain.BumpGlobalCombined);
			}
		}
		Terrain terrain = (Terrain)blendedObject.GetComponent(typeof(Terrain));
		if ((bool)terrain)
		{
			underlying_renderer.lightmapIndex = terrain.lightmapIndex;
			underlying_renderer.lightmapScaleOffset = terrain.lightmapScaleOffset;
			underlying_renderer.realtimeLightmapIndex = terrain.realtimeLightmapIndex;
			underlying_renderer.realtimeLightmapScaleOffset = terrain.realtimeLightmapScaleOffset;
		}
		else
		{
			underlying_renderer.lightmapIndex = blendedObject.GetComponent<Renderer>().lightmapIndex;
			underlying_renderer.lightmapScaleOffset = blendedObject.GetComponent<Renderer>().lightmapScaleOffset;
			underlying_renderer.realtimeLightmapIndex = blendedObject.GetComponent<Renderer>().realtimeLightmapIndex;
			underlying_renderer.realtimeLightmapScaleOffset = blendedObject.GetComponent<Renderer>().realtimeLightmapScaleOffset;
		}
		if (Sticked)
		{
			if ((bool)terrain)
			{
				GetComponent<Renderer>().lightmapIndex = terrain.lightmapIndex;
				GetComponent<Renderer>().lightmapScaleOffset = terrain.lightmapScaleOffset;
				GetComponent<Renderer>().realtimeLightmapIndex = terrain.realtimeLightmapIndex;
				GetComponent<Renderer>().realtimeLightmapScaleOffset = terrain.realtimeLightmapScaleOffset;
			}
			else
			{
				GetComponent<Renderer>().lightmapIndex = blendedObject.GetComponent<Renderer>().lightmapIndex;
				GetComponent<Renderer>().lightmapScaleOffset = blendedObject.GetComponent<Renderer>().lightmapScaleOffset;
				GetComponent<Renderer>().realtimeLightmapIndex = blendedObject.GetComponent<Renderer>().realtimeLightmapIndex;
				GetComponent<Renderer>().realtimeLightmapScaleOffset = blendedObject.GetComponent<Renderer>().realtimeLightmapScaleOffset;
			}
		}
	}
}