using UnityEngine;

public static class vp_MathUtility
{
	public static float NaNSafeFloat(float value, float prevValue = 0f)
	{
		value = ((!double.IsNaN(value)) ? value : prevValue);
		return value;
	}

	public static Vector2 NaNSafeVector2(Vector2 vector, Vector2 prevVector = default(Vector2))
	{
		vector.x = ((!double.IsNaN(vector.x)) ? vector.x : prevVector.x);
		vector.y = ((!double.IsNaN(vector.y)) ? vector.y : prevVector.y);
		return vector;
	}

	public static Vector3 NaNSafeVector3(Vector3 vector, Vector3 prevVector = default(Vector3))
	{
		vector.x = ((!double.IsNaN(vector.x)) ? vector.x : prevVector.x);
		vector.y = ((!double.IsNaN(vector.y)) ? vector.y : prevVector.y);
		vector.z = ((!double.IsNaN(vector.z)) ? vector.z : prevVector.z);
		return vector;
	}

	public static Quaternion NaNSafeQuaternion(Quaternion quaternion, Quaternion prevQuaternion = default(Quaternion))
	{
		quaternion.x = ((!double.IsNaN(quaternion.x)) ? quaternion.x : prevQuaternion.x);
		quaternion.y = ((!double.IsNaN(quaternion.y)) ? quaternion.y : prevQuaternion.y);
		quaternion.z = ((!double.IsNaN(quaternion.z)) ? quaternion.z : prevQuaternion.z);
		quaternion.w = ((!double.IsNaN(quaternion.w)) ? quaternion.w : prevQuaternion.w);
		return quaternion;
	}

	public static Vector3 SnapToZero(Vector3 value, float epsilon = 0.0001f)
	{
		value.x = ((!(Mathf.Abs(value.x) < epsilon)) ? value.x : 0f);
		value.y = ((!(Mathf.Abs(value.y) < epsilon)) ? value.y : 0f);
		value.z = ((!(Mathf.Abs(value.z) < epsilon)) ? value.z : 0f);
		return value;
	}

	public static float SnapToZero(float value, float epsilon = 0.0001f)
	{
		value = ((!(Mathf.Abs(value) < epsilon)) ? value : 0f);
		return value;
	}

	public static float ReduceDecimals(float value, float factor = 1000f)
	{
		return Mathf.Round(value * factor) / factor;
	}

	public static bool IsOdd(int val)
	{
		return val % 2 != 0;
	}

	public static float Sinus(float rate, float amp, float offset = 0f)
	{
		return Mathf.Cos((Time.time + offset) * rate) * amp;
	}
}