public void TestAsinh()
{
double d = 0;
d = MathX.asinh(0);
Assert.AreEqual(d, 0, "asinh 0");
d = MathX.asinh(1);
Assert.AreEqual(0.881373587, d, "asinh 1 ");
d = MathX.asinh(-1);
Assert.AreEqual(-0.881373587, d, "asinh -1 ");
d = MathX.asinh(-100);
Assert.AreEqual(-5.298342366, d, "asinh -100 ");
d = MathX.asinh(100);
Assert.AreEqual(5.298342366, d, "asinh 100 ");
d = MathX.asinh(200000);
Assert.AreEqual(12.899219826096400, d, "asinh 200000");
d = MathX.asinh(-200000);
Assert.AreEqual(-12.899223853137, d, "asinh -200000 ");
}
public void TestSumxmy2()
{
double d = 0;
double[] xarr = null;
double[] yarr = null;
xarr = new double[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
yarr = new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
d = MathX.sumxmy2(xarr, yarr);
Assert.AreEqual(10, d, "sumxmy2 ");
xarr = new double[] { -1, -2, -3, -4, -5, -6, -7, -8, -9, -10 };
yarr = new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
d = MathX.sumxmy2(xarr, yarr);
Assert.AreEqual(1330, d, "sumxmy2 ");
xarr = new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
yarr = new double[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
d = MathX.sumxmy2(xarr, yarr);
Assert.AreEqual(10, d, "sumxmy2 ");
xarr = new double[] { 10 };
yarr = new double[] { 9 };
d = MathX.sumxmy2(xarr, yarr);
Assert.AreEqual(1, d, "sumxmy2 ");
xarr = new double[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
yarr = new double[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
d = MathX.sumxmy2(xarr, yarr);
Assert.AreEqual(0, d, "sumxmy2 ");
}
public void TestFactorial()
{
int n = 0;
double s = 0;
n = 0;
s = MathX.factorial(n);
Assert.AreEqual(1, s, "Factorial ");
n = 1;
s = MathX.factorial(n);
Assert.AreEqual(1, s, "Factorial ");
n = 10;
s = MathX.factorial(n);
Assert.AreEqual(3628800, s, "Factorial ");
n = 99;
s = MathX.factorial(n);
Assert.AreEqual(9.33262154439E+155, s, "Factorial ");
n = -1;
s = MathX.factorial(n);
Assert.AreEqual(Double.NaN, s, "Factorial ");
n = int.MaxValue;
s = MathX.factorial(n);
Assert.AreEqual(Double.PositiveInfinity, s, "Factorial ");
}
public void TestSum()
{
double[] d = new double[100];
d[0] = 1.1; d[1] = 2.1; d[2] = 3.1; d[3] = 4.1;
d[4] = 5.1; d[5] = 6.1; d[6] = 7.1; d[7] = 8.1;
d[8] = 9.1; d[9] = 10.1; d[10] = 11.1; d[11] = 12.1;
d[12] = 13.1; d[13] = 14.1; d[14] = 15.1; d[15] = 16.1;
d[16] = 17.1; d[17] = 18.1; d[18] = 19.1; d[19] = 20.1;
double s = MathX.sum(d);
Assert.AreEqual(212, s, "Sum ");
d = new double[1000];
s = MathX.sum(d);
Assert.AreEqual(0, s, "Sum ");
d[0] = -1.1; d[1] = 2.1; d[2] = -3.1; d[3] = 4.1;
d[4] = -5.1; d[5] = 6.1; d[6] = -7.1; d[7] = 8.1;
d[8] = -9.1; d[9] = 10.1; d[10] = -11.1; d[11] = 12.1;
d[12] = -13.1; d[13] = 14.1; d[14] = -15.1; d[15] = 16.1;
d[16] = -17.1; d[17] = 18.1; d[18] = -19.1; d[19] = 20.1;
s = MathX.sum(d);
Assert.AreEqual(10, s, "Sum ");
d[0] = -1.1; d[1] = -2.1; d[2] = -3.1; d[3] = -4.1;
d[4] = -5.1; d[5] = -6.1; d[6] = -7.1; d[7] = -8.1;
d[8] = -9.1; d[9] = -10.1; d[10] = -11.1; d[11] = -12.1;
d[12] = -13.1; d[13] = -14.1; d[14] = -15.1; d[15] = -16.1;
d[16] = -17.1; d[17] = -18.1; d[18] = -19.1; d[19] = -20.1;
s = MathX.sum(d);
Assert.AreEqual(-212, s, "Sum ");
}
public void TestSinh()
{
double d = 0;
d = MathX.sinh(0);
Assert.AreEqual(0, d, "sinh 0");
d = MathX.sinh(1);
Assert.AreEqual(1.175201194, d, "sinh 1 ");
d = MathX.sinh(-1);
Assert.AreEqual(-1.175201194, d, "sinh -1 ");
d = MathX.sinh(-100);
Assert.AreEqual(-1.344058570908070E+43, d, "sinh -100 ");
d = MathX.sinh(100);
Assert.AreEqual(1.344058570908070E+43, d, "sinh 100 ");
d = MathX.sinh(15);
Assert.AreEqual(1634508.686, d, "sinh 15");
d = MathX.sinh(-15);
Assert.AreEqual(-1634508.686, d, "sinh -15 ");
d = MathX.sinh(0.1);
Assert.AreEqual(0.10016675, d, "sinh 0.1");
d = MathX.sinh(-0.1);
Assert.AreEqual(-0.10016675, d, "sinh -0.1 ");
}
public void TestAtanh()
{
double d = 0;
d = MathX.atanh(0);
Assert.AreEqual(d, 0, "atanh 0");
d = MathX.atanh(1);
Assert.AreEqual(Double.PositiveInfinity, d, "atanh 1 ");
d = MathX.atanh(-1);
Assert.AreEqual(Double.NegativeInfinity, d, "atanh -1 ");
d = MathX.atanh(-100);
Assert.AreEqual(Double.NaN, d, "atanh -100 ");
d = MathX.atanh(100);
Assert.AreEqual(Double.NaN, d, "atanh 100 ");
d = MathX.atanh(200000);
Assert.AreEqual(Double.NaN, d, "atanh 200000");
d = MathX.atanh(-200000);
Assert.AreEqual(Double.NaN, d, "atanh -200000 ");
d = MathX.atanh(0.1);
Assert.AreEqual(0.100335348, d, "atanh 0.1");
d = MathX.atanh(-0.1);
Assert.AreEqual(-0.100335348, d, "atanh -0.1 ");
}
public override VikingState Update()
{
if (viking.QueuePosition == 0)
{
if (!viking.desireVisualiser.IsShowing)
{
viking.desireVisualiser.ShowNewDesire(viking.Data.desireSeatVisualisation);
}
float remappedMood = MathX.RemapClamped(viking.Stats.Mood, viking.Data.impatientMoodThreshold, viking.Stats.StartMood, 0, 1);
viking.desireVisualiser.SetDesireColor(remappedMood);
viking.desireVisualiser.SetTweenSpeed(remappedMood);
viking.Stats.Decline();
}
if (viking.Stats.Mood < viking.Data.impatientMoodThreshold)
{
if (PlayerManager.Instance != null)
{
return(new BrawlingVikingState(viking, Util.RandomElement(PlayerManager.Instance.Players)));
}
return(TakeRandomSeat());
}
return(this);
}
public void TestCosh()
{
double d = 0;
d = MathX.cosh(0);
Assert.AreEqual(1, d, "cosh 0");
d = MathX.cosh(1);
Assert.AreEqual(1.543080635, d, "cosh 1 ");
d = MathX.cosh(-1);
Assert.AreEqual(1.543080635, d, "cosh -1 ");
d = MathX.cosh(-100);
Assert.AreEqual(1.344058570908070E+43, d, "cosh -100 ");
d = MathX.cosh(100);
Assert.AreEqual(1.344058570908070E+43, d, "cosh 100 ");
d = MathX.cosh(15);
Assert.AreEqual(1634508.686, d, "cosh 15");
d = MathX.cosh(-15);
Assert.AreEqual(1634508.686, d, "cosh -15 ");
d = MathX.cosh(0.1);
Assert.AreEqual(1.005004168, d, "cosh 0.1");
d = MathX.cosh(-0.1);
Assert.AreEqual(1.005004168, d, "cosh -0.1 ");
}
protected override double SingleNoise(double x, double y)
{
int ix = MathX.FastFloor(x);
double fx0 = x - ix;
double fx1 = fx0 - 1;
int jx = ix & 255;
int iy = MathX.FastFloor(y);
double fy0 = y - iy;
double fy1 = fy0 - 1;
int jy = iy & 255;
var py = Perm[jy];
int index = PermMod12[jx + py];
int index1 = PermMod12[jx + 1 + py];
var g0 = Gradients[index];
var g1 = Gradients[index1];
double vx0 = g0.x * fx0 + g0.y * fy0;
double vx1 = g1.x * fx1 + g1.y * fy0;
double vy0 = vx0 + fx0 * (vx1 - vx0);
var py1 = Perm[jy + 1];
int index2 = PermMod12[jx + py1];
int index3 = PermMod12[jx + 1 + py1];
var g2 = Gradients[index2];
var g3 = Gradients[index3];
vx0 = g2.x * fx0 + g2.y * fy1;
vx1 = g3.x * fx1 + g3.y * fy1;
double vy1 = vx0 + fx0 * (vx1 - vx0);
return(vy0 + fy0 * (vy1 - vy0));
}
private void DropCoin()
{
Coin coin = Object.Instantiate(viking.coinPrefab, viking.transform.position + new Vector3(0, 2, 0), Quaternion.identity);
coin.ThrowInDirection(MathX.RandomDirectionInQuarterSphere(-viking.transform.forward, Vector3.up));
coinsToDrop--;
}
static float SCR_DrawFPS(float y)
{
var new_y = MathX.FtoiFast(y) + 300;
// don't use serverTime, because that will be drifting to correct for internet lag changes, timescales, timedemos, etc
var t = SysW.Milliseconds;
var frameTime = t - SCR_DrawFPS_previous;
SCR_DrawFPS_previous = t;
SCR_DrawFPS_previousTimes[SCR_DrawFPS_index % FPS_FRAMES] = frameTime;
SCR_DrawFPS_index++;
if (SCR_DrawFPS_index > FPS_FRAMES)
{
// average multiple frames together to smooth changes out a bit
var total = 0;
for (var i = 0; i < FPS_FRAMES; i++)
{
total += SCR_DrawFPS_previousTimes[i];
}
if (total == 0)
{
total = 1;
}
SCR_DrawFPS_fps = 10000 * FPS_FRAMES / total;
SCR_DrawFPS_fps = (SCR_DrawFPS_fps + 5) / 10;
var s = $"{SCR_DrawFPS_fps}fps";
var w = s.Length * R.SMALLCHAR_WIDTH;
renderSystem.DrawSmallStringExt((634 / 2) - w, new_y, s, colorWhite, true, localConsole.charSetShader);
}
return(y + R.BIGCHAR_HEIGHT + 4);
}
public void TestAtanh()
{
double d = 0;
d = MathX.Atanh(0);
AssertEquals("atanh 0", d, 0);
d = MathX.Atanh(1);
AssertEquals("atanh 1 ", Double.PositiveInfinity, d);
d = MathX.Atanh(-1);
AssertEquals("atanh -1 ", Double.NegativeInfinity, d);
d = MathX.Atanh(-100);
AssertEquals("atanh -100 ", Double.NaN, d);
d = MathX.Atanh(100);
AssertEquals("atanh 100 ", Double.NaN, d);
d = MathX.Atanh(200000);
AssertEquals("atanh 200000", Double.NaN, d);
d = MathX.Atanh(-200000);
AssertEquals("atanh -200000 ", Double.NaN, d);
d = MathX.Atanh(0.1);
AssertEquals("atanh 0.1", 0.100335348, d);
d = MathX.Atanh(-0.1);
AssertEquals("atanh -0.1 ", -0.100335348, d);
}
public void TestTanh()
{
double d = 0;
d = MathX.Tanh(0);
AssertEquals("tanh 0", 0, d);
d = MathX.Tanh(1);
AssertEquals("tanh 1 ", 0.761594156, d);
d = MathX.Tanh(-1);
AssertEquals("tanh -1 ", -0.761594156, d);
d = MathX.Tanh(-100);
AssertEquals("tanh -100 ", -1, d);
d = MathX.Tanh(100);
AssertEquals("tanh 100 ", 1, d);
d = MathX.Tanh(15);
AssertEquals("tanh 15", 1, d);
d = MathX.Tanh(-15);
AssertEquals("tanh -15 ", -1, d);
d = MathX.Tanh(0.1);
AssertEquals("tanh 0.1", 0.099667995, d);
d = MathX.Tanh(-0.1);
AssertEquals("tanh -0.1 ", -0.099667995, d);
}
public void TestFactorial()
{
int n = 0;
double s = 0;
n = 0;
s = MathX.Factorial(n);
AssertEquals("Factorial ", 1, s);
n = 1;
s = MathX.Factorial(n);
AssertEquals("Factorial ", 1, s);
n = 10;
s = MathX.Factorial(n);
AssertEquals("Factorial ", 3628800, s);
n = 99;
s = MathX.Factorial(n);
AssertEquals("Factorial ", 9.33262154439E+155, s);
n = -1;
s = MathX.Factorial(n);
AssertEquals("Factorial ", Double.NaN, s);
n = Int32.MaxValue;
s = MathX.Factorial(n);
AssertEquals("Factorial ", Double.PositiveInfinity, s);
}
public void TestAsinh()
{
double d = 0;
d = MathX.Asinh(0);
AssertEquals("asinh 0", d, 0);
d = MathX.Asinh(1);
AssertEquals("asinh 1 ", 0.881373587, d);
d = MathX.Asinh(-1);
AssertEquals("asinh -1 ", -0.881373587, d);
d = MathX.Asinh(-100);
AssertEquals("asinh -100 ", -5.298342366, d);
d = MathX.Asinh(100);
AssertEquals("asinh 100 ", 5.298342366, d);
d = MathX.Asinh(200000);
AssertEquals("asinh 200000", 12.899219826096400, d);
d = MathX.Asinh(-200000);
AssertEquals("asinh -200000 ", -12.899223853137, d);
}
public void TestSinh()
{
double d = 0;
d = MathX.Sinh(0);
AssertEquals("sinh 0", 0, d);
d = MathX.Sinh(1);
AssertEquals("sinh 1 ", 1.175201194, d);
d = MathX.Sinh(-1);
AssertEquals("sinh -1 ", -1.175201194, d);
d = MathX.Sinh(-100);
AssertEquals("sinh -100 ", -1.344058570908070E+43, d);
d = MathX.Sinh(100);
AssertEquals("sinh 100 ", 1.344058570908070E+43, d);
d = MathX.Sinh(15);
AssertEquals("sinh 15", 1634508.686, d);
d = MathX.Sinh(-15);
AssertEquals("sinh -15 ", -1634508.686, d);
d = MathX.Sinh(0.1);
AssertEquals("sinh 0.1", 0.10016675, d);
d = MathX.Sinh(-0.1);
AssertEquals("sinh -0.1 ", -0.10016675, d);
}
public void TestSumsq()
{
double[] d = new double[100];
d[0] = 1.1; d[1] = 2.1; d[2] = 3.1; d[3] = 4.1;
d[4] = 5.1; d[5] = 6.1; d[6] = 7.1; d[7] = 8.1;
d[8] = 9.1; d[9] = 10.1; d[10] = 11.1; d[11] = 12.1;
d[12] = 13.1; d[13] = 14.1; d[14] = 15.1; d[15] = 16.1;
d[16] = 17.1; d[17] = 18.1; d[18] = 19.1; d[19] = 20.1;
double s = MathX.Sumsq(d);
AssertEquals("Sumsq ", 2912.2, s);
d = new double[1000];
s = MathX.Sumsq(d);
AssertEquals("Sumsq ", 0, s);
d[0] = -1.1; d[1] = 2.1; d[2] = -3.1; d[3] = 4.1;
d[4] = -5.1; d[5] = 6.1; d[6] = -7.1; d[7] = 8.1;
d[8] = -9.1; d[9] = 10.1; d[10] = -11.1; d[11] = 12.1;
d[12] = -13.1; d[13] = 14.1; d[14] = -15.1; d[15] = 16.1;
d[16] = -17.1; d[17] = 18.1; d[18] = -19.1; d[19] = 20.1;
s = MathX.Sumsq(d);
AssertEquals("Sumsq ", 2912.2, s);
d[0] = -1.1; d[1] = -2.1; d[2] = -3.1; d[3] = -4.1;
d[4] = -5.1; d[5] = -6.1; d[6] = -7.1; d[7] = -8.1;
d[8] = -9.1; d[9] = -10.1; d[10] = -11.1; d[11] = -12.1;
d[12] = -13.1; d[13] = -14.1; d[14] = -15.1; d[15] = -16.1;
d[16] = -17.1; d[17] = -18.1; d[18] = -19.1; d[19] = -20.1;
s = MathX.Sumsq(d);
AssertEquals("Sumsq ", 2912.2, s);
}
protected override double SingleNoise(double x, double y, double z)
{
// Create a unit-length cube aligned along an integer boundary. This cube
// surrounds the input point.
int x0 = Align(x);
int x1 = x0 + 1;
int y0 = Align(y);
int y1 = y0 + 1;
int z0 = Align(z);
int z1 = z0 + 1;
// Map the difference between the coordinates of the input value and the
// coordinates of the cube's outer-lower-left vertex onto an S-curve.
double xs = (x - x0);
double ys = (y - y0);
double zs = (z - z0);
// Now calculate the noise values at each vertex of the cube. To generate
// the coherent-noise value at the input point, interpolate these eight
// noise values using the S-curve value as the interpolant (trilinear
// interpolation.)
return(MathX.Lerp(
Gradient(x, y, z, x0, y0, z0),
Gradient(x, y, z, x1, y0, z0),
Gradient(x, y, z, x0, y1, z0),
Gradient(x, y, z, x1, y1, z0),
Gradient(x, y, z, x0, y0, z1),
Gradient(x, y, z, x1, y0, z1),
Gradient(x, y, z, x0, y1, z1),
Gradient(x, y, z, x1, y1, z1),
xs, ys, zs));
}
public void TestMax()
{
double[] d = new double[100];
d[0] = 1.1; d[1] = 2.1; d[2] = 3.1; d[3] = 4.1;
d[4] = 5.1; d[5] = 6.1; d[6] = 7.1; d[7] = 8.1;
d[8] = 9.1; d[9] = 10.1; d[10] = 11.1; d[11] = 12.1;
d[12] = 13.1; d[13] = 14.1; d[14] = 15.1; d[15] = 16.1;
d[16] = 17.1; d[17] = 18.1; d[18] = 19.1; d[19] = 20.1;
double m = MathX.Max(d);
AssertEquals("Max ", 20.1, m);
d = new double[1000];
m = MathX.Max(d);
AssertEquals("Max ", 0, m);
d[0] = -1.1; d[1] = 2.1; d[2] = -3.1; d[3] = 4.1;
d[4] = -5.1; d[5] = 6.1; d[6] = -7.1; d[7] = 8.1;
d[8] = -9.1; d[9] = 10.1; d[10] = -11.1; d[11] = 12.1;
d[12] = -13.1; d[13] = 14.1; d[14] = -15.1; d[15] = 16.1;
d[16] = -17.1; d[17] = 18.1; d[18] = -19.1; d[19] = 20.1;
m = MathX.Max(d);
AssertEquals("Max ", 20.1, m);
d = new double[20];
d[0] = -1.1; d[1] = -2.1; d[2] = -3.1; d[3] = -4.1;
d[4] = -5.1; d[5] = -6.1; d[6] = -7.1; d[7] = -8.1;
d[8] = -9.1; d[9] = -10.1; d[10] = -11.1; d[11] = -12.1;
d[12] = -13.1; d[13] = -14.1; d[14] = -15.1; d[15] = -16.1;
d[16] = -17.1; d[17] = -18.1; d[18] = -19.1; d[19] = -20.1;
m = MathX.Max(d);
AssertEquals("Max ", -1.1, m);
}
public void TestTanh()
{
double d = 0;
d = MathX.tanh(0);
Assert.AreEqual(0, d, "tanh 0");
d = MathX.tanh(1);
Assert.AreEqual(0.761594156, d, "tanh 1 ");
d = MathX.tanh(-1);
Assert.AreEqual(-0.761594156, d, "tanh -1 ");
d = MathX.tanh(-100);
Assert.AreEqual(-1, d, "tanh -100 ");
d = MathX.tanh(100);
Assert.AreEqual(1, d, "tanh 100 ");
d = MathX.tanh(15);
Assert.AreEqual(1, d, "tanh 15");
d = MathX.tanh(-15);
Assert.AreEqual(-1, d, "tanh -15 ");
d = MathX.tanh(0.1);
Assert.AreEqual(0.099667995, d, "tanh 0.1");
d = MathX.tanh(-0.1);
Assert.AreEqual(-0.099667995, d, "tanh -0.1 ");
}
public void TestCosh()
{
double d = 0;
d = MathX.Cosh(0);
AssertEquals("cosh 0", 1, d);
d = MathX.Cosh(1);
AssertEquals("cosh 1 ", 1.543080635, d);
d = MathX.Cosh(-1);
AssertEquals("cosh -1 ", 1.543080635, d);
d = MathX.Cosh(-100);
AssertEquals("cosh -100 ", 1.344058570908070E+43, d);
d = MathX.Cosh(100);
AssertEquals("cosh 100 ", 1.344058570908070E+43, d);
d = MathX.Cosh(15);
AssertEquals("cosh 15", 1634508.686, d);
d = MathX.Cosh(-15);
AssertEquals("cosh -15 ", 1634508.686, d);
d = MathX.Cosh(0.1);
AssertEquals("cosh 0.1", 1.005004168, d);
d = MathX.Cosh(-0.1);
AssertEquals("cosh -0.1 ", 1.005004168, d);
}
public List <FactBaseQuery> SoftCombineQueries(params List <FactBaseQuery>[] querypool)
{
var nonempty = querypool.Where(i => i.Count > 0);
var combinedqueries = MathX.CartesianProduct(nonempty);
var mergedqueries = new List <FactBaseQuery>();
foreach (var combination in combinedqueries)
{
var mergedquery = new FactBaseQuery();
var combinationlist = combination.ToList();
var ix = 0;
foreach (var fbq in combinationlist)
{
//Merge(fbq, mergedquery);
mergedquery.NrOfDictFilters += fbq.NrOfDictFilters;
//if (ix == combinationlist.Count - 1)
//{
// Merge(fbq, mergedquery);
//}
FactBaseQuery.Merge(fbq, mergedquery);
ix++;
}
mergedqueries.Add(mergedquery);
}
return(mergedqueries);
}
public void ShouldSumRangesWhenDistanceBetweenNumbers(
float a, float b, float expected
)
{
var distance = MathX.Distance(a, b);
Assert.AreEqual(expected, distance);
}
void Swap()
{
var a = 3;
var b = 5;
MathX.Swap(ref a, ref b);
Assert.Equal((5, 3), (a, b));
}
public static float Remap(
this float value,
float from1,
float to1,
float from2,
float to2
)
=> MathX.Remap(value, from1, to1, from2, to2);
protected int CalculateSortingOrder()
{
Vector2 gridPosition = snappingCamera.WorldToGrid((positionSource != null ? positionSource : transform).position);
float t = 1 - MathX.Fract(gridPosition.y);
int order = Mathf.FloorToInt(t * (SortingValues - OffsetValues) - (SortingValues - OffsetValues) / 2) + orderOffset;
return(order);
}
public override void OnTransitionProgress(double progress)
{
var nextIndex = StartIndex - progress;
nextIndex = MathX.Clamp(nextIndex, -1, HBS.Search.Callback.MaxPageIndex + 1);
SwipeDirection = nextIndex > Shelf.SelectedIndex ? Direction.Right : Direction.Left;
Shelf.SelectedIndex = nextIndex;
}
private IEnumerator CoFadeOutVignette(float duration)
{
for (float time = 0; time < duration; time += Time.deltaTime)
{
SetVignetteAlpha(MathX.EaseInQuad(vignetteColor.a, 0, time / duration));
yield return(null);
}
canvas.SetActive(false);
}
private IEnumerator CoFadeInVignette(float duration)
{
canvas.SetActive(true);
for (float time = 0; time < duration; time += Time.deltaTime)
{
SetVignetteAlpha(MathX.EaseOutQuad(0, vignetteColor.a, time / duration));
yield return(null);
}
}
public void ShouldClampWithoutOrder()
{
var numPositive = MathX.ClampWithoutOrder(6f, 2f, -2f);
Assert.AreEqual(numPositive, 2f);
var numNegative = MathX.ClampWithoutOrder(-6f, 2f, -2f);
Assert.AreEqual(numNegative, -2f);
}
