using UnityEngine;

public class MegaGUI : MonoBehaviour
{
	public GameObject source;

	public GameObject ground;

	private bool showcommon;

	private bool showgcommon;

	private MegaModifier[] mods;

	private MegaModifier[] gmods;

	private bool[] showmod;

	private bool[] showgmod;

	private MegaModifiers context;

	private MegaModifiers gcontext;

	public bool showparams = true;

	public bool showgparams = true;

	private GUIContent[] Axislist;

	public float objsize = 2f;

	private GUIContent[] EAxislist;

	private Vector2 pos = default(Vector2);

	public float sx = 232f;

	private Rect windowRect = new Rect(10f, 5f, 200f, 500f);

	public Material mat;

	public Material gmat;

	private GUIContent[] MatList;

	private Color gr = new Color(1f, 0.5f, 0.5f);

	private Color gg = new Color(0.5f, 1f, 0.5f);

	private Color gb = new Color(0.5f, 0.5f, 1f);

	public float butwidth = 166f;

	public Color bcol = new Color(245f, 177f, 17f);

	public Color bcol1 = new Color(96f, 149f, 255f);

	public bool ShowGui = true;

	public float dsize = 10f;

	public float svd = 0.9f;

	private float svh;

	private float lastscreenheight;

	public GUISkin skin;

	private void Start()
	{
		if (source != null)
		{
			context = source.GetComponent<MegaModifyObject>();
			if (context != null)
			{
				mods = source.GetComponents<MegaModifier>();
				showmod = new bool[mods.Length];
			}
			gcontext = ground.GetComponent<MegaModifyObject>();
			if (gcontext != null)
			{
				gmods = ground.GetComponents<MegaModifier>();
				showgmod = new bool[gmods.Length];
			}
		}
		SizeChange();
	}

	private void InitAxis()
	{
		if (Axislist == null)
		{
			Axislist = new GUIContent[3];
			Axislist[0] = new GUIContent("X");
			Axislist[1] = new GUIContent("Y");
			Axislist[2] = new GUIContent("Z");
		}
	}

	private void InitEAxis()
	{
		if (EAxislist == null)
		{
			EAxislist = new GUIContent[3];
			EAxislist[0] = new GUIContent("X");
			EAxislist[1] = new GUIContent("Y");
			EAxislist[2] = new GUIContent("XY");
		}
	}

	private void InitMatList()
	{
		if (MatList == null)
		{
			MatList = new GUIContent[5];
			MatList[0] = new GUIContent("Ice");
			MatList[1] = new GUIContent("Glass");
			MatList[2] = new GUIContent("Jelly");
			MatList[3] = new GUIContent("Plastic");
			MatList[4] = new GUIContent("Custom");
		}
	}

	public int EAxisXYZ(string name, int val)
	{
		InitEAxis();
		GUILayout.Label(name);
		return GUILayout.SelectionGrid(val, EAxislist, 3, "toggle");
	}

	public int EditInt(string name, int val)
	{
		GUILayout.Label(name);
		string s = GUILayout.TextField(val.ToString());
		int.TryParse(s, out val);
		return val;
	}

	public int XYZ(string name, int val)
	{
		InitAxis();
		GUILayout.Label(name);
		return GUILayout.SelectionGrid(val, Axislist, 3, "toggle");
	}

	public float ProSlider(string name, float val, float low, float high, float pro)
	{
		GUILayout.Label(name + " " + val.ToString("0.000"));
		return GUILayout.HorizontalSlider(val, low * pro * 0.5f, high * pro * 0.5f);
	}

	public float ProSlider(float val, float low, float high, float pro)
	{
		return GUILayout.HorizontalSlider(val, low * pro * 0.5f, high * pro * 0.5f);
	}

	public float Slider(string name, float val, float low, float high)
	{
		float num = (val - low) / (high - low);
		GUILayout.Label(name + " " + val.ToString("0.000"));
		float num2 = GUILayout.HorizontalSlider(num, 0f, 1f);
		float num3 = num2 - num;
		if (Input.GetKey(KeyCode.LeftShift))
		{
			num3 *= 0.001f;
		}
		num += num3;
		return low + num * (high - low);
	}

	public float AngleSlider(string name, float val, float scl)
	{
		GUILayout.Label(name + " " + val.ToString("0.000"));
		return GUILayout.HorizontalSlider(val, -360f * scl, 360f * scl);
	}

	public float AngleSlider(float val, float scl)
	{
		return GUILayout.HorizontalSlider(val, -360f * scl, 360f * scl);
	}

	public Vector3 AngleSlider(string name, ref Vector3 val, float scl)
	{
		GUILayout.Label(name + " " + val.x.ToString("0.0") + " " + val.y.ToString("0.0") + " " + val.z.ToString("0.0"));
		GUI.color = gr;
		val.x = AngleSlider(val.x, scl);
		GUI.color = gg;
		val.y = AngleSlider(val.y, scl);
		GUI.color = gb;
		val.z = AngleSlider(val.z, scl);
		GUI.color = Color.white;
		return val;
	}

	public Vector3 ProSlider(string name, ref Vector3 val, float low, float high, float pro)
	{
		GUILayout.Label(name + " " + val.x.ToString("0.0") + " " + val.y.ToString("0.0") + " " + val.z.ToString("0.0"));
		GUI.color = gr;
		val.x = ProSlider(val.x, low, high, pro);
		GUI.color = gg;
		val.y = ProSlider(val.y, low, high, pro);
		GUI.color = gb;
		val.z = ProSlider(val.z, low, high, pro);
		GUI.color = Color.white;
		return val;
	}

	public Color ColSlider(string name, ref Color val, float low, float high, float pro)
	{
		GUILayout.Label(name + " " + val.r.ToString("0.0") + " " + val.g.ToString("0.0") + " " + val.b.ToString("0.0"));
		GUI.color = gr;
		val.r = ProSlider(val.r, low, high, pro);
		GUI.color = gg;
		val.g = ProSlider(val.g, low, high, pro);
		GUI.color = gb;
		val.b = ProSlider(val.b, low, high, pro);
		GUI.color = Color.white;
		val.a = ProSlider(val.a, low, high, pro);
		return val;
	}

	private void ShowCommon(MegaModifier md, int i)
	{
		if ((i & 1) == 1)
		{
			GUI.color = bcol;
		}
		else
		{
			GUI.color = bcol1;
		}
		if (GUILayout.Button(md.ModName(), GUILayout.Width(butwidth)))
		{
			showmod[i] = !showmod[i];
		}
		if (!showmod[i])
		{
			return;
		}
		GUI.color = Color.white;
		md.ModEnabled = GUILayout.Toggle(md.ModEnabled, "Enabled");
		if (showcommon)
		{
			ProSlider("Offset", ref md.Offset, -4f, 4f, objsize);
			ProSlider("Pos", ref md.gizmoPos, -4f, 4f, objsize);
			ProSlider("Rot", ref md.gizmoRot, -90f, 90f, objsize);
			int num = EditInt("Order", md.Order);
			if (num != md.Order)
			{
				md.Order = num;
				context.Sort();
			}
		}
	}

	private void ShowGCommon(MegaModifier md, int i)
	{
		if ((i & 1) == 1)
		{
			GUI.color = bcol;
		}
		else
		{
			GUI.color = bcol1;
		}
		if (GUILayout.Button(md.ModName(), GUILayout.Width(butwidth)))
		{
			showgmod[i] = !showgmod[i];
		}
		GUI.color = Color.white;
		if (!showgmod[i])
		{
			return;
		}
		md.ModEnabled = GUILayout.Toggle(md.ModEnabled, "Enabled");
		if (showgcommon)
		{
			ProSlider("Offset", ref md.Offset, -4f, 4f, objsize);
			ProSlider("Pos", ref md.gizmoPos, -4f, 4f, objsize);
			ProSlider("Rot", ref md.gizmoRot, -90f, 90f, objsize);
			int num = EditInt("Order", md.Order);
			if (num != md.Order)
			{
				md.Order = num;
				gcontext.Sort();
			}
		}
	}

	private void ShowGUI(MegaModifier mod)
	{
		switch (mod.ModName())
		{
		case "Bend":
		{
			MegaBend megaBend = (MegaBend)mod;
			megaBend.angle = AngleSlider("Angle", megaBend.angle, 2f);
			megaBend.dir = AngleSlider("Direction", megaBend.dir, 1f);
			megaBend.axis = (MegaAxis)XYZ("Axis", (int)megaBend.axis);
			megaBend.doRegion = GUILayout.Toggle(megaBend.doRegion, "DoRegion");
			if (megaBend.doRegion)
			{
				megaBend.from = Slider("From", megaBend.from, -40f, 0f);
				megaBend.to = Slider("To", megaBend.to, 0f, 40f);
			}
			break;
		}
		case "Hump":
		{
			MegaHump megaHump = (MegaHump)mod;
			float pro = mod.bbox.Size().magnitude * 4f;
			megaHump.amount = ProSlider("Amount", megaHump.amount, -2f, 2f, pro);
			megaHump.cycles = Slider("Cycles", megaHump.cycles, 0f, 20f);
			megaHump.phase = Slider("Phase", megaHump.phase, 0f, 10f);
			megaHump.axis = (MegaAxis)XYZ("Axis", (int)megaHump.axis);
			megaHump.animate = GUILayout.Toggle(megaHump.animate, "Animate");
			if (megaHump.animate)
			{
				megaHump.speed = Slider("Speed", megaHump.speed, -10f, 10f);
			}
			break;
		}
		case "Twist":
		{
			MegaTwist megaTwist = (MegaTwist)mod;
			megaTwist.angle = AngleSlider("Angle", megaTwist.angle, 2f);
			megaTwist.Bias = Slider("Bias", megaTwist.Bias, -40f, 40f);
			megaTwist.axis = (MegaAxis)XYZ("Axis", (int)megaTwist.axis);
			megaTwist.doRegion = GUILayout.Toggle(megaTwist.doRegion, "DoRegion");
			if (megaTwist.doRegion)
			{
				megaTwist.from = Slider("From", megaTwist.from, -40f, 0f);
				megaTwist.to = Slider("To", megaTwist.to, 0f, 40f);
			}
			break;
		}
		case "Taper":
		{
			MegaTaper megaTaper = (MegaTaper)mod;
			megaTaper.amount = Slider("Amount", megaTaper.amount, -10f, 10f);
			megaTaper.axis = (MegaAxis)XYZ("Axis", (int)megaTaper.axis);
			megaTaper.EAxis = (MegaEffectAxis)EAxisXYZ("EffectAxis", (int)megaTaper.EAxis);
			megaTaper.dir = AngleSlider("Direction", megaTaper.dir, 1f);
			megaTaper.crv = Slider("Curve", megaTaper.crv, -10f, 10f);
			megaTaper.sym = GUILayout.Toggle(megaTaper.sym, "Symmetry");
			megaTaper.doRegion = GUILayout.Toggle(megaTaper.doRegion, "Limit Effect");
			if (megaTaper.doRegion)
			{
				megaTaper.from = ProSlider("From", megaTaper.from, 0f, 1f, objsize);
				megaTaper.to = ProSlider("To", megaTaper.to, 0f, 1f, objsize);
			}
			break;
		}
		case "FFD3x3x3":
		{
			MegaFFD megaFFD = (MegaFFD)mod;
			for (int i = 0; i < 27; i++)
			{
				string text = "p" + i;
				megaFFD.pt[i] = ProSlider(text, ref megaFFD.pt[i], -2f, 2f, objsize);
			}
			break;
		}
		case "Noise":
		{
			MegaNoise megaNoise = (MegaNoise)mod;
			megaNoise.Scale = Slider("Scale", megaNoise.Scale, 0f, 10f);
			megaNoise.Freq = Slider("Freq", megaNoise.Freq, 0f, 30f);
			megaNoise.Phase = Slider("Phase", megaNoise.Phase, 0f, 10f);
			megaNoise.Strength = ProSlider("Strength", ref megaNoise.Strength, 0f, 1f, objsize);
			megaNoise.Animate = GUILayout.Toggle(megaNoise.Animate, "Animate");
			megaNoise.Fractal = GUILayout.Toggle(megaNoise.Fractal, "Fractal");
			if (megaNoise.Fractal)
			{
				megaNoise.Rough = Slider("Rough", megaNoise.Rough, 0f, 1f);
				megaNoise.Iterations = Slider("Iterations", megaNoise.Iterations, 0f, 10f);
			}
			break;
		}
		case "Ripple":
		{
			MegaRipple megaRipple = (MegaRipple)mod;
			megaRipple.animate = GUILayout.Toggle(megaRipple.animate, "Animate");
			if (megaRipple.animate)
			{
				megaRipple.Speed = Slider("Speed", megaRipple.Speed, -4f, 4f);
			}
			megaRipple.amp = ProSlider("Amp", megaRipple.amp, -1f, 1f, objsize);
			megaRipple.amp2 = ProSlider("Amp2", megaRipple.amp2, -1f, 1f, objsize);
			megaRipple.flex = Slider("Flex", megaRipple.flex, -10f, 10f);
			megaRipple.wave = Slider("Wave", megaRipple.wave, -25f, 25f);
			megaRipple.phase = Slider("Phase", megaRipple.phase, -100f, 100f);
			megaRipple.Decay = Slider("decay", megaRipple.Decay, 0f, 500f);
			break;
		}
		case "Wave":
		{
			MegaWave megaWave = (MegaWave)mod;
			megaWave.animate = GUILayout.Toggle(megaWave.animate, "Animate");
			if (megaWave.animate)
			{
				megaWave.Speed = Slider("Speed", megaWave.Speed, -4f, 4f);
			}
			megaWave.amp = ProSlider("Amp", megaWave.amp, -1f, 1f, objsize * 0.75f);
			megaWave.amp2 = ProSlider("Amp2", megaWave.amp2, -1f, 1f, objsize * 0.75f);
			megaWave.flex = Slider("Flex", megaWave.flex, -10f, 10f);
			megaWave.wave = Slider("Wave", megaWave.wave, -100f, 100f);
			megaWave.phase = Slider("Phase", megaWave.phase, -100f, 100f);
			megaWave.Decay = Slider("decay", megaWave.Decay, 0f, 50f);
			megaWave.dir = Slider("Direction", megaWave.dir, 0f, 90f);
			break;
		}
		case "Stretch":
		{
			MegaStretch megaStretch = (MegaStretch)mod;
			megaStretch.amount = Slider("Amount", megaStretch.amount, -4f, 4f);
			megaStretch.amplify = Slider("Amplify", megaStretch.amplify, -2f, 2f);
			megaStretch.axis = (MegaAxis)XYZ("Axis", (int)megaStretch.axis);
			break;
		}
		case "Bubble":
		{
			MegaBubble megaBubble = (MegaBubble)mod;
			megaBubble.radius = ProSlider("Radius", megaBubble.radius, -1f, 4f, objsize);
			megaBubble.falloff = ProSlider("Falloff", megaBubble.falloff, -1f, 1f, objsize);
			break;
		}
		case "Spherify":
		{
			MegaSpherify megaSpherify = (MegaSpherify)mod;
			megaSpherify.percent = Slider("Percent", megaSpherify.percent, 0f, 100f);
			break;
		}
		case "Skew":
		{
			MegaSkew megaSkew = (MegaSkew)mod;
			megaSkew.amount = ProSlider("Amount", megaSkew.amount, -2f, 2f, objsize);
			megaSkew.dir = AngleSlider("Dir", megaSkew.dir, 1f);
			megaSkew.axis = (MegaAxis)XYZ("Axis", (int)megaSkew.axis);
			break;
		}
		case "Melt":
		{
			MegaMelt megaMelt = (MegaMelt)mod;
			megaMelt.Amount = Slider("Amount ", megaMelt.Amount, 0f, 100f);
			megaMelt.Spread = Slider("Spread", megaMelt.Spread, 0f, 100f);
			InitMatList();
			GUILayout.Label("Solidity");
			megaMelt.MaterialType = (MegaMeltMat)GUILayout.SelectionGrid((int)megaMelt.MaterialType, MatList, 2, "toggle");
			if (megaMelt.MaterialType == MegaMeltMat.Custom)
			{
				megaMelt.Solidity = Slider("Custom", megaMelt.Solidity, 0f, 10f);
			}
			megaMelt.axis = (MegaAxis)XYZ("Axis", (int)megaMelt.axis);
			megaMelt.FlipAxis = GUILayout.Toggle(megaMelt.FlipAxis, "Flip Axis");
			break;
		}
		}
	}

	public void ShowGUI()
	{
		if (!context)
		{
			return;
		}
		GUI.color = Color.white;
		if (GUILayout.Button("Logo Params", GUILayout.Width(butwidth)))
		{
			showparams = !showparams;
		}
		if (!showparams)
		{
			return;
		}
		context.Enabled = GUILayout.Toggle(context.Enabled, "Enabled");
		context.recalcnorms = GUILayout.Toggle(context.recalcnorms, "Recalc Normals");
		showcommon = GUILayout.Toggle(showcommon, "Common Params");
		for (int i = 0; i < mods.Length; i++)
		{
			ShowCommon(mods[i], i);
			if (showmod[i])
			{
				ShowGUI(mods[i]);
			}
		}
	}

	private void ShowGroundGUI()
	{
		if (!gcontext)
		{
			return;
		}
		GUI.color = Color.white;
		if (GUILayout.Button("Ground Params", GUILayout.Width(butwidth)))
		{
			showgparams = !showgparams;
		}
		if (!showgparams)
		{
			return;
		}
		gcontext.Enabled = GUILayout.Toggle(gcontext.Enabled, "Enabled");
		gcontext.recalcnorms = GUILayout.Toggle(gcontext.recalcnorms, "Recalc Normals");
		showgcommon = GUILayout.Toggle(showgcommon, "Common Params");
		for (int i = 0; i < gmods.Length; i++)
		{
			ShowGCommon(gmods[i], i);
			if (showgmod[i])
			{
				ShowGUI(gmods[i]);
			}
		}
	}

	private void DoWindow(int windowID)
	{
		pos = GUILayout.BeginScrollView(pos, GUILayout.Width(sx), GUILayout.Height(svh));
		if (mat != null)
		{
			Color val = mat.color;
			mat.color = ColSlider("Col", ref val, 0f, 1f, 2f);
		}
		if (gmat != null)
		{
			Color val2 = gmat.color;
			gmat.color = ColSlider("Ground", ref val2, 0f, 1f, 2f);
		}
		ShowGUI();
		ShowGroundGUI();
		GUILayout.EndScrollView();
		GUI.DragWindow();
	}

	private void Update()
	{
		if (Input.GetKeyUp(KeyCode.Escape))
		{
			ShowGui = !ShowGui;
		}
	}

	private void SizeChange()
	{
		windowRect.yMax = windowRect.yMin + ((float)Screen.height - dsize);
		svh = windowRect.yMax - windowRect.yMin - svd;
		lastscreenheight = Screen.height;
	}

	private void OnGUI()
	{
		if (ShowGui && mods != null)
		{
			GUI.skin = skin;
			if ((float)Screen.height != lastscreenheight)
			{
				SizeChange();
			}
			windowRect = GUILayout.Window(0, windowRect, DoWindow, source.name + " - Modifiers", GUILayout.Width(100f));
		}
	}
}