static public void AssertEquals(fint fvalue, float f) { if (fvalue.ToFloat() != f) { throw new Exception(string.Format("Expected {0}, got {1}", f, fvalue.ToFloat().ToString())); } }
static public void AssertEquals(fint fvalue, int i) { if (fvalue.ToInt() != i) { throw new Exception(string.Format("Expected {0}, got {1}", i, fvalue.ToInt().ToString())); } }
static public void TestFIntFloating() { //Test basic value fint onePointOne = fint.CreateFromFloat(1.1f); AssertAlmostEquals(onePointOne, 1.1f); //Test addition fint twoPointTwo = onePointOne + onePointOne; AssertAlmostEquals(twoPointTwo, 2.2f); //Test substraction AssertAlmostEquals(twoPointTwo - onePointOne, 1.1f); AssertEquals(twoPointTwo - onePointOne, onePointOne); //Test negation AssertAlmostEquals(-twoPointTwo, -2.2f); //Test multiplication AssertAlmostEquals(twoPointTwo * twoPointTwo, 2.2f * 2.2f); //Test division AssertEquals(twoPointTwo / twoPointTwo, 1.0f); AssertAlmostEquals(twoPointTwo / (twoPointTwo * fint.CreateFromFloat(2.0f)), 0.5f); }
static public void AssertAlmostEqualsAngleRadians(fint fvalue, float f) { if (Math.Abs(fvalue.ToFloat() - f) > (float)(2.0f * Math.PI / 180.0f)) { throw new Exception(string.Format("Expected {0}, got {1}", f, fvalue.ToFloat().ToString())); } }
public static fint Atan2(fint F1, fint F2) { if (F2.raw == 0 && F1.raw == 0) { return(fint.zero); } fint result = fint.zero; if (F2 > fint.zero) { result = Atan(F1 / F2); } else if (F2 < fint.zero) { if (F1 >= fint.zero) { result = (PI - Atan(Abs(F1 / F2))); } else { result = -(PI - Atan(Abs(F1 / F2))); } } else { result = (F1 >= fint.zero ? PI : -PI) / fint.CreateFromInt(2); } return(result); }
private void MoveAboveFloor(VoxelComponent voxel) { FVector3 position = voxel.position; fint radius = voxel.radius; FVector3 deltaBottom; if (voxel.shape == VoxelShape.Sphere) { deltaBottom = FVector3.down * radius; } else { deltaBottom = FVector3.down * voxel.height * fint.half; } FVector3 bottom = position + deltaBottom; int x = bottom.x.ToInt(); int y = bottom.y.ToInt(); int z = bottom.z.ToInt(); if (IsValidPosition(x, y, z)) { if (GetVoxel(x, y, z) != 0 && IsValidPosition(x, y + 1, z)) { position.y = fint.CreateFromInt(y + 1); voxel.position.y = position.y - deltaBottom.y; } } }
static public void AssertEquals(fint fvalue1, fint fvalue2) { if (fvalue1 != fvalue2) { throw new Exception(string.Format("Expected {0}, got {1}", fvalue1.ToFloat(), fvalue2.ToFloat())); } }
static public void AssertAlmostEqualsTrig(fint fvalue, float f) { if (Math.Abs(fvalue.ToFloat() - f) > 0.09f) { throw new Exception(string.Format("Expected {0}, got {1}", f, fvalue.ToFloat().ToString())); } }
public static FVector2 ClampMagnitude(FVector2 vector, fint maxLength) { if (vector.sqrMagnitude > maxLength * maxLength) { return(vector.normalized * maxLength); } return(vector); }
protected override void OnInit(Parameters parameters) { shape = parameters.GetParameter <VoxelShape>(PARAMETER_SHAPE, VoxelShape.Sphere); radius = parameters.GetParameter <fint>(PARAMETER_RADIUS, fint.half); height = parameters.GetParameter <fint>(PARAMETER_HEIGHT, fint.two); position = parameters.GetParameter <FVector3>(PARAMETER_POSITION, FVector3.zero); useGravity = parameters.GetParameter <bool>(PARAMETER_USE_GRAVITY, true); color = parameters.GetParameter <FVector3>(PARAMETER_COLOR, FVector3.one); }
static public void BenchmarkFixed(int iterations) { fint result = fint.zero; for (int i = 0; i < iterations; i++) { result += FVector3.one.magnitude; } }
public static FVector3 Project(FVector3 vector, FVector3 onNormal) { fint num = FVector3.Dot(onNormal, onNormal); if (num.raw < 1) { return(FVector3.zero); } return(onNormal * FVector3.Dot(vector, onNormal) / num); }
/// <summary> /// Create a fixed-int number from parts. For example, to create 1.5 pass in 1 and 500. /// </summary> /// <param name="PreDecimal">The number above the decimal. For 1.5, this would be 1.</param> /// <param name="PostDecimal">The number below the decimal, to three digits. /// For 1.5, this would be 500. For 1.005, this would be 5.</param> /// <returns>A fixed-int representation of the number parts</returns> public static fint FromParts(int PreDecimal, int PostDecimal) { fint f = fint.CreateFromInt(PreDecimal); if (PostDecimal != 0) { f += (fint.CreateFromInt(PostDecimal) / fint.CreateFromInt(1000)); } return(f); }
public static FVector2 Normalize(FVector2 value) { fint magnitude = FVector2.Magnitude(value); if (magnitude.raw > 1) { return(value / magnitude); } return(FVector3.zero); }
public static FVector2 MoveTowards(FVector2 current, FVector2 target, fint maxDistanceDelta) { FVector2 a = target - current; fint magnitude = a.magnitude; if (magnitude <= maxDistanceDelta || magnitude == fint.zero) { return(target); } return(current + a / magnitude * maxDistanceDelta); }
public static fint Abs(fint F) { if (F.raw < 0) { return(-F); } else { return(F); } }
public static fint Clamp01(fint value) { if (value < fint.zero) { return(fint.zero); } if (value > fint.one) { return(fint.one); } return(value); }
public void Normalize() { fint num = FVector3.Magnitude(this); if (num.raw > 1) { this /= num; } else { this = FVector3.zero; } }
public void Normalize() { fint magnitude = this.magnitude; if (magnitude.raw > 1) { this /= magnitude; } else { this = FVector2.zero; } }
private static fint sin_lookup(fint i, fint j) { if (j.raw > 0 && j < fint.CreateRaw(10) && i < fint.CreateRaw(90)) { return(fint.CreateRaw(SIN_TABLE[i.raw]) + ((fint.CreateRaw(SIN_TABLE[i.raw + 1]) - fint.CreateRaw(SIN_TABLE[i.raw])) / fint.CreateRaw(10)) * j); } else { return(fint.CreateRaw(SIN_TABLE[i.raw])); } }
public static fint Clamp(fint value, fint min, fint max) { if (value < min) { value = min; } else { if (value > max) { value = max; } } return(value); }
public static fint Sqrt(fint f) { if (f.raw > 0x3e8000) { return(Sqrt(f, 16 * 3 / 4)); } else if (f.raw > 0x64000) { return(Sqrt(f, 12 * 2 / 3)); } else { return(Sqrt(f, 8 * 2 / 3)); } }
public static fint Sqrt(fint f, int NumberOfIterations) { if (f.raw < 0) //NaN in Math.Sqrt { throw new ArithmeticException("Input Error"); } if (f.raw == 0) { return(fint.zero); } #if USE_OPTIMIZATIONS long fraw = f.raw; long frawshift = (fraw << fint.SHIFT_AMOUNT); long k = fraw + fint.one.raw >> 1; for (int i = 0; i < NumberOfIterations; i++) { k = (k + (frawshift / k)) >> 1; } if (k < 0) { throw new ArithmeticException("Overflow"); } return(fint.CreateRaw((int)k)); #else fint k = f + fint.one >> 1; for (int i = 0; i < NumberOfIterations; i++) { k = (k + (f / k)) >> 1; } if (k.raw < 0) { throw new ArithmeticException("Overflow"); } return(k); #endif }
public static fint Min(params fint[] values) { int num = values.Length; if (num == 0) { return(fint.zero); } fint num2 = values[0]; for (int i = 1; i < num; i++) { if (values[i] < num2) { num2 = values[i]; } } return(num2); }
public static fint Asin(fint F) { bool isNegative = F.raw < 0; F = Abs(F); if (F > fint.one) { throw new ArithmeticException("Bad Asin Input:" + F.ToFloat()); } fint f1 = mul(mul(mul(mul( fint.CreateRaw(145103 >> fint.SHIFT_AMOUNT), F) - fint.CreateRaw(599880 >> fint.SHIFT_AMOUNT), F) + fint.CreateRaw(1420468 >> fint.SHIFT_AMOUNT), F) - fint.CreateRaw(3592413 >> fint.SHIFT_AMOUNT), F) + fint.CreateRaw(26353447 >> fint.SHIFT_AMOUNT); fint f2 = HalfPI - (Sqrt(fint.one - F) * f1); return(isNegative ? -f2 : f2); }
public void Update(fint realDeltaTime) { if (!initialized) { return; } accumulatedTime += realDeltaTime; while (initialized && accumulatedTime >= SimulationTime.deltaTime) { accumulatedTime -= SimulationTime.deltaTime; //Updated components for (int i = 0; i < componentManagers.Count; i++) { componentManagers[i].Update(); } SimulationTime.simulationTime += SimulationTime.deltaTime; } }
static public void TestFIntBasic() { //Test basic value fint one = fint.one; AssertEquals(one, 1); AssertEquals(one, 1.0f); //Test addition fint two = one + one; AssertEquals(two, 2); AssertEquals(two, 2.0f); //Test substraction fint zero = two - two; AssertEquals(zero, 0); AssertEquals(zero, 0.0f); //Test negation fint minustwo = -two; AssertEquals(minustwo, -2); AssertEquals(minustwo, -2.0f); //Test multiplication fint minusfour = two * minustwo; AssertEquals(minusfour, -4); AssertEquals(minusfour, -4.0f); //Test division AssertEquals(minusfour / two, -2); AssertEquals(minusfour / two, -2.0f); }
public static fint Sin(fint i) { fint j = fint.zero; for ( ; i.raw < 0; i += fint.CreateRaw(25736)) { ; } if (i > fint.CreateRaw(25736)) { i %= fint.CreateRaw(25736); } fint k = (i * fint.CreateRaw(10)) / fint.CreateRaw(714); if (i.raw != 0 && i != fint.CreateRaw(6434) && i != fint.CreateRaw(12868) && i != fint.CreateRaw(19302) && i != fint.CreateRaw(25736)) { j = (i * fint.CreateRaw(100)) / fint.CreateRaw(714) - k * fint.CreateRaw(10); } if (k <= fint.CreateRaw(90)) { return(sin_lookup(k, j)); } if (k <= fint.CreateRaw(180)) { return(sin_lookup(fint.CreateRaw(180) - k, j)); } if (k <= fint.CreateRaw(270)) { return(-sin_lookup(k - fint.CreateRaw(180), j)); } else { return(-sin_lookup(fint.CreateRaw(360) - k, j)); } }
public static FVector2 Lerp(FVector2 from, FVector2 to, fint t) { t = FMath.Clamp01(t); return(new FVector2(from.x + (to.x - from.x) * t, from.y + (to.y - from.y) * t)); }
public void Set(fint new_x, fint new_y) { this.x = new_x; this.y = new_y; }