UltimateFishing/Assets/Scripts/Assembly-CSharp/MegaPointCache.cs

using UnityEngine;

[AddComponentMenu("Modifiers/Point Cache")]
public class MegaPointCache : MegaModifier
{
	public float time;

	public bool animated;

	public float speed = 1f;

	public float maxtime = 1f;

	public MegaRepeatMode LoopMode = MegaRepeatMode.PingPong;

	public MegaInterpMethod interpMethod = MegaInterpMethod.Linear;

	public MegaPCVert[] Verts;

	public float weight = 1f;

	public bool framedelay = true;

	public MegaBlendAnimMode blendMode = MegaBlendAnimMode.Additive;

	private int numPoints;

	private float startFrame;

	private float sampleRate;

	private int numSamples;

	private float t;

	private float alpha;

	private float dalpha;

	private int sindex;

	private int sindex1;

	public bool showmapping;

	public float mappingSize = 0.001f;

	public int mapStart;

	public int mapEnd;

	public bool havemapping;

	public float scl = 1f;

	public bool flipyz;

	public bool negx;

	public bool negz;

	public float adjustscl = 1f;

	public Vector3 adjustoff = Vector3.zero;

	private bool skipframe = true;

	public override string ModName()
	{
		return "Point Cache";
	}

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

	private void LinearAbs(MegaModifiers mc, int start, int end)
	{
		for (int i = start; i < end; i++)
		{
			Vector3 vector = Verts[i].points[sindex];
			Vector3 vector2 = Verts[i].points[sindex1];
			vector.x += (vector2.x - vector.x) * dalpha;
			vector.y += (vector2.y - vector.y) * dalpha;
			vector.z += (vector2.z - vector.z) * dalpha;
			for (int j = 0; j < Verts[i].indices.Length; j++)
			{
				sverts[Verts[i].indices[j]] = vector;
			}
		}
	}

	private void LinearAbsWeighted(MegaModifiers mc, int start, int end)
	{
		for (int i = start; i < end; i++)
		{
			Vector3 vector = Verts[i].points[sindex];
			Vector3 vector2 = Verts[i].points[sindex1];
			vector.x += (vector2.x - vector.x) * dalpha;
			vector.y += (vector2.y - vector.y) * dalpha;
			vector.z += (vector2.z - vector.z) * dalpha;
			float num = mc.selection[Verts[i].indices[0]];
			vector2 = verts[Verts[i].indices[0]];
			vector = vector2 + (vector - vector2) * num;
			for (int j = 0; j < Verts[i].indices.Length; j++)
			{
				sverts[Verts[i].indices[j]] = vector;
			}
		}
	}

	private void LinearRel(MegaModifiers mc, int start, int end)
	{
		for (int i = start; i < end; i++)
		{
			int num = Verts[i].indices[0];
			Vector3 vector = mc.verts[num];
			Vector3 vector2 = Verts[i].points[sindex];
			Vector3 vector3 = Verts[i].points[sindex1];
			vector2.x += (vector3.x - vector2.x) * dalpha - vector.x;
			vector2.y += (vector3.y - vector2.y) * dalpha - vector.y;
			vector2.z += (vector3.z - vector2.z) * dalpha - vector.z;
			vector3 = verts[Verts[i].indices[0]];
			vector2.x = vector3.x + vector2.x * weight;
			vector2.y = vector3.y + vector2.y * weight;
			vector2.z = vector3.z + vector2.z * weight;
			for (int j = 0; j < Verts[i].indices.Length; j++)
			{
				int num2 = Verts[i].indices[j];
				sverts[num2] = vector2;
			}
		}
	}

	private void LinearRelWeighted(MegaModifiers mc, int start, int end)
	{
		for (int i = start; i < end; i++)
		{
			int num = Verts[i].indices[0];
			Vector3 vector = verts[num];
			Vector3 vector2 = Verts[i].points[sindex];
			Vector3 vector3 = Verts[i].points[sindex1];
			vector2.x += (vector3.x - vector2.x) * dalpha - vector.x;
			vector2.y += (vector3.y - vector2.y) * dalpha - vector.y;
			vector2.z += (vector3.z - vector2.z) * dalpha - vector.z;
			float num2 = mc.selection[Verts[i].indices[0]] * weight;
			vector3 = verts[Verts[i].indices[0]];
			vector2.x = vector3.x + vector2.x * num2;
			vector2.y = vector3.y + vector2.y * num2;
			vector2.z = vector3.z + vector2.z * num2;
			for (int j = 0; j < Verts[i].indices.Length; j++)
			{
				int num3 = Verts[i].indices[j];
				sverts[num3] = vector2;
			}
		}
	}

	private void NoInterpAbs(MegaModifiers mc, int start, int end)
	{
		for (int i = start; i < end; i++)
		{
			Vector3 vector = Verts[i].points[sindex];
			for (int j = 0; j < Verts[i].indices.Length; j++)
			{
				sverts[Verts[i].indices[j]] = vector;
			}
		}
	}

	private void NoInterpAbsWeighted(MegaModifiers mc, int start, int end)
	{
		for (int i = start; i < end; i++)
		{
			Vector3 vector = Verts[i].points[sindex];
			float num = mc.selection[Verts[i].indices[0]] * weight;
			Vector3 vector2 = verts[Verts[i].indices[0]];
			vector = vector2 + (vector - vector2) * num;
			for (int j = 0; j < Verts[i].indices.Length; j++)
			{
				sverts[Verts[i].indices[j]] = vector;
			}
		}
	}

	private void NoInterpRel(MegaModifiers mc, int start, int end)
	{
		for (int i = start; i < end; i++)
		{
			int num = Verts[i].indices[0];
			Vector3 vector = Verts[i].points[sindex] - verts[num];
			Vector3 vector2 = verts[Verts[i].indices[0]];
			vector.x = vector2.x + vector.x * weight;
			vector.y = vector2.y + vector.y * weight;
			vector.z = vector2.z + vector.z * weight;
			for (int j = 0; j < Verts[i].indices.Length; j++)
			{
				int num2 = Verts[i].indices[j];
				sverts[num2] = vector;
			}
		}
	}

	private void NoInterpRelWeighted(MegaModifiers mc, int start, int end)
	{
		for (int i = start; i < end; i++)
		{
			int num = Verts[i].indices[0];
			Vector3 vector = Verts[i].points[sindex] - verts[num];
			float num2 = mc.selection[Verts[i].indices[0]] * weight;
			Vector3 vector2 = verts[Verts[i].indices[0]];
			vector = vector2 + (vector - vector2) * num2;
			for (int j = 0; j < Verts[i].indices.Length; j++)
			{
				int num3 = Verts[i].indices[j];
				sverts[num3] = vector;
			}
		}
	}

	public override void Modify(MegaModifiers mc)
	{
		if (Verts != null)
		{
			switch (interpMethod)
			{
			case MegaInterpMethod.Linear:
				switch (blendMode)
				{
				case MegaBlendAnimMode.Additive:
					LinearRel(mc, 0, Verts.Length);
					break;
				case MegaBlendAnimMode.Replace:
					LinearAbs(mc, 0, Verts.Length);
					break;
				}
				break;
			case MegaInterpMethod.Bez:
				switch (blendMode)
				{
				case MegaBlendAnimMode.Additive:
					LinearRel(mc, 0, Verts.Length);
					break;
				case MegaBlendAnimMode.Replace:
					LinearAbs(mc, 0, Verts.Length);
					break;
				}
				break;
			case MegaInterpMethod.None:
				switch (blendMode)
				{
				case MegaBlendAnimMode.Additive:
					NoInterpRel(mc, 0, Verts.Length);
					break;
				case MegaBlendAnimMode.Replace:
					NoInterpAbs(mc, 0, Verts.Length);
					break;
				}
				break;
			}
		}
		else
		{
			for (int i = 0; i < verts.Length; i++)
			{
				sverts[i] = verts[i];
			}
		}
	}

	public void ModifyInstance(MegaModifiers mc, float itime)
	{
		if (Verts != null)
		{
			switch (LoopMode)
			{
			case MegaRepeatMode.Loop:
				t = Mathf.Repeat(itime, maxtime);
				break;
			case MegaRepeatMode.PingPong:
				t = Mathf.PingPong(itime, maxtime);
				break;
			case MegaRepeatMode.Clamp:
				t = Mathf.Clamp(itime, 0f, maxtime);
				break;
			}
			alpha = t / maxtime;
			float num = (float)(Verts[0].points.Length - 1) * alpha;
			sindex = (int)num;
			dalpha = num - (float)sindex;
			if (sindex == Verts[0].points.Length - 1)
			{
				sindex1 = sindex;
				dalpha = 0f;
			}
			else
			{
				sindex1 = sindex + 1;
			}
			switch (interpMethod)
			{
			case MegaInterpMethod.Linear:
				switch (blendMode)
				{
				case MegaBlendAnimMode.Additive:
					LinearRel(mc, 0, Verts.Length);
					break;
				case MegaBlendAnimMode.Replace:
					LinearAbs(mc, 0, Verts.Length);
					break;
				}
				break;
			case MegaInterpMethod.Bez:
				switch (blendMode)
				{
				case MegaBlendAnimMode.Additive:
					LinearRel(mc, 0, Verts.Length);
					break;
				case MegaBlendAnimMode.Replace:
					LinearAbs(mc, 0, Verts.Length);
					break;
				}
				break;
			case MegaInterpMethod.None:
				switch (blendMode)
				{
				case MegaBlendAnimMode.Additive:
					NoInterpRel(mc, 0, Verts.Length);
					break;
				case MegaBlendAnimMode.Replace:
					NoInterpAbs(mc, 0, Verts.Length);
					break;
				}
				break;
			}
		}
		else
		{
			for (int i = 0; i < verts.Length; i++)
			{
				sverts[i] = verts[i];
			}
		}
	}

	public void SetAnim(float _t)
	{
		time = _t;
		t = _t;
		skipframe = true;
	}

	public override bool ModLateUpdate(MegaModContext mc)
	{
		if (!Prepare(mc))
		{
			return false;
		}
		if (animated)
		{
			if (framedelay && skipframe)
			{
				skipframe = false;
			}
			else
			{
				time += Time.deltaTime * speed;
			}
		}
		switch (LoopMode)
		{
		case MegaRepeatMode.Loop:
			t = Mathf.Repeat(time, maxtime);
			break;
		case MegaRepeatMode.PingPong:
			t = Mathf.PingPong(time, maxtime);
			break;
		case MegaRepeatMode.Clamp:
			t = Mathf.Clamp(time, 0f, maxtime);
			break;
		}
		alpha = t / maxtime;
		float num = (float)(Verts[0].points.Length - 1) * alpha;
		sindex = (int)num;
		dalpha = num - (float)sindex;
		if (sindex == Verts[0].points.Length - 1)
		{
			sindex1 = sindex;
			dalpha = 0f;
		}
		else
		{
			sindex1 = sindex + 1;
		}
		return true;
	}

	public override bool Prepare(MegaModContext mc)
	{
		if (Verts != null && Verts.Length > 0 && Verts[0].indices != null && Verts[0].indices.Length > 0)
		{
			return true;
		}
		return false;
	}

	public override void DoWork(MegaModifiers mc, int index, int start, int end, int cores)
	{
		ModifyCompressedMT(mc, index, cores);
	}

	public void ModifyCompressedMT(MegaModifiers mc, int tindex, int cores)
	{
		if (Verts == null)
		{
			return;
		}
		int num = Verts.Length / cores;
		int num2 = tindex * num;
		int end = num2 + num;
		if (tindex == cores - 1)
		{
			end = Verts.Length;
		}
		switch (interpMethod)
		{
		case MegaInterpMethod.Linear:
			switch (blendMode)
			{
			case MegaBlendAnimMode.Additive:
				LinearRel(mc, num2, end);
				break;
			case MegaBlendAnimMode.Replace:
				LinearAbs(mc, num2, end);
				break;
			}
			break;
		case MegaInterpMethod.Bez:
			switch (blendMode)
			{
			case MegaBlendAnimMode.Additive:
				LinearRel(mc, num2, end);
				break;
			case MegaBlendAnimMode.Replace:
				LinearAbs(mc, num2, end);
				break;
			}
			break;
		case MegaInterpMethod.None:
			switch (blendMode)
			{
			case MegaBlendAnimMode.Additive:
				NoInterpRel(mc, num2, end);
				break;
			case MegaBlendAnimMode.Replace:
				NoInterpAbs(mc, num2, end);
				break;
			}
			break;
		}
	}
}