using UnityEngine;

[AddComponentMenu("Modifiers/Morph-O-Matic")]
public class MegaMorphOMatic : MegaMorphBase
{
	public bool UseLimit;

	public float Max;

	public float Min;

	public float importScale = 1f;

	public bool flipyz;

	public bool negx;

	public bool glUseLimit;

	public float glMin;

	public float glMax = 1f;

	public float tolerance = 0.0001f;

	public bool animate;

	public float atime;

	public float animtime;

	public float looptime;

	public MegaRepeatMode repeatMode;

	public float speed = 1f;

	public Vector3[] oPoints;

	public MegaMomVertMap[] mapping;

	public override string ModName()
	{
		return "Morph-O-Matic";
	}

	public override string GetHelpURL()
	{
		return "?page_id=1521";
	}

	public override bool ModLateUpdate(MegaModContext mc)
	{
		if (animate)
		{
			animtime += Time.deltaTime * speed;
			switch (repeatMode)
			{
			case MegaRepeatMode.Loop:
				animtime = Mathf.Repeat(animtime, looptime);
				break;
			case MegaRepeatMode.Clamp:
				animtime = Mathf.Clamp(animtime, 0f, looptime);
				break;
			}
			SetAnim(animtime);
		}
		return Prepare(mc);
	}

	public override bool Prepare(MegaModContext mc)
	{
		if (chanBank != null && chanBank.Count > 0)
		{
			return true;
		}
		return false;
	}

	private Vector3 Cubic(MegaMorphTarget t, int pointnum, float alpha)
	{
		Vector3 delta = t.mompoints[pointnum].delta;
		delta.x *= alpha;
		delta.y *= alpha;
		delta.z *= alpha;
		return delta;
	}

	public static void Bez3D(out Vector3 b, ref Vector3[] p, float u)
	{
		Vector3 vector = p[0] + (p[1] - p[0]) * u;
		Vector3 vector2 = p[1] + (p[2] - p[1]) * u;
		Vector3 vector3 = vector + (vector2 - vector) * u;
		vector = p[2] + (p[3] - p[2]) * u;
		Vector3 vector4 = vector2 + (vector - vector2) * u;
		b = vector3 + (vector4 - vector3) * u;
	}

	public override void Modify(MegaModifiers mc)
	{
		verts.CopyTo(sverts, 0);
		for (int i = 0; i < chanBank.Count; i++)
		{
			MegaMorphChan megaMorphChan = chanBank[i];
			megaMorphChan.UpdatePercent();
			float num = megaMorphChan.Percent;
			if (num == megaMorphChan.fChannelPercent)
			{
				MegaMorphTarget megaMorphTarget = megaMorphChan.mTargetCache[megaMorphChan.targ];
				for (int j = 0; j < megaMorphTarget.mompoints.Length; j++)
				{
					int id = megaMorphTarget.mompoints[j].id;
					int num2 = mapping[id].indices.Length;
					Vector3 vector = megaMorphChan.diff[j];
					for (int k = 0; k < num2; k++)
					{
						int num3 = mapping[id].indices[k];
						sverts[num3].x += vector.x;
						sverts[num3].y += vector.y;
						sverts[num3].z += vector.z;
					}
				}
				continue;
			}
			megaMorphChan.fChannelPercent = num;
			if (megaMorphChan.mTargetCache == null || megaMorphChan.mTargetCache.Count <= 0 || !megaMorphChan.mActiveOverride)
			{
				continue;
			}
			if (megaMorphChan.mUseLimit || glUseLimit)
			{
				num = ((!glUseLimit) ? Mathf.Clamp(num, megaMorphChan.mSpinmin, megaMorphChan.mSpinmax) : Mathf.Clamp(num, glMin, glMax));
			}
			int num4 = 0;
			float num5 = 0f;
			if (num < megaMorphChan.mTargetCache[0].percent)
			{
				num4 = 0;
				num5 = (num - megaMorphChan.mTargetCache[num4].percent) / (megaMorphChan.mTargetCache[num4 + 1].percent - megaMorphChan.mTargetCache[num4].percent);
			}
			else
			{
				int num6 = megaMorphChan.mTargetCache.Count - 1;
				if (num >= megaMorphChan.mTargetCache[num6].percent)
				{
					num4 = num6 - 1;
					num5 = (num - megaMorphChan.mTargetCache[num4].percent) / (megaMorphChan.mTargetCache[num4 + 1].percent - megaMorphChan.mTargetCache[num4].percent);
				}
				else
				{
					for (int l = 1; l < megaMorphChan.mTargetCache.Count; l++)
					{
						if (num < megaMorphChan.mTargetCache[l].percent)
						{
							num4 = l - 1;
							num5 = (num - megaMorphChan.mTargetCache[num4].percent) / (megaMorphChan.mTargetCache[l].percent - megaMorphChan.mTargetCache[num4].percent);
							break;
						}
					}
				}
			}
			MegaMorphTarget megaMorphTarget2 = megaMorphChan.mTargetCache[num4];
			megaMorphChan.targ = num4;
			for (int m = 0; m < megaMorphTarget2.mompoints.Length; m++)
			{
				int id2 = megaMorphTarget2.mompoints[m].id;
				Vector3 start = megaMorphTarget2.mompoints[m].start;
				start.x += megaMorphTarget2.mompoints[m].delta.x * num5;
				start.y += megaMorphTarget2.mompoints[m].delta.y * num5;
				start.z += megaMorphTarget2.mompoints[m].delta.z * num5;
				megaMorphChan.diff[m] = start;
				for (int n = 0; n < mapping[id2].indices.Length; n++)
				{
					int num7 = mapping[id2].indices[n];
					sverts[num7].x += start.x;
					sverts[num7].y += start.y;
					sverts[num7].z += start.z;
				}
			}
		}
	}

	public override void PrepareMT(MegaModifiers mc, int cores)
	{
	}

	public override void DoWork(MegaModifiers mc, int index, int start, int end, int cores)
	{
		if (index == 0)
		{
			Modify(mc);
		}
	}
}