niko
649 lines
17 KiB
C#
649 lines
17 KiB
C#
using System;
|
|
using System.Runtime.CompilerServices;
|
|
using UnityEngine.Internal;
|
|
using UnityEngine.Scripting;
|
|
using UnityEngineInternal;
|
|
|
|
namespace UnityEngine
|
|
{
|
|
// Token: 0x02000087 RID: 135
|
|
public struct Mathf
|
|
{
|
|
// Token: 0x060009E9 RID: 2537
|
|
[ThreadAndSerializationSafe]
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
public static extern int ClosestPowerOfTwo(int value);
|
|
|
|
// Token: 0x060009EA RID: 2538
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
public static extern float GammaToLinearSpace(float value);
|
|
|
|
// Token: 0x060009EB RID: 2539
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
public static extern float LinearToGammaSpace(float value);
|
|
|
|
// Token: 0x060009EC RID: 2540 RVA: 0x0000EAE4 File Offset: 0x0000CCE4
|
|
public static Color CorrelatedColorTemperatureToRGB(float kelvin)
|
|
{
|
|
Color color;
|
|
Mathf.INTERNAL_CALL_CorrelatedColorTemperatureToRGB(kelvin, out color);
|
|
return color;
|
|
}
|
|
|
|
// Token: 0x060009ED RID: 2541
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_CALL_CorrelatedColorTemperatureToRGB(float kelvin, out Color value);
|
|
|
|
// Token: 0x060009EE RID: 2542
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
public static extern bool IsPowerOfTwo(int value);
|
|
|
|
// Token: 0x060009EF RID: 2543
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
public static extern int NextPowerOfTwo(int value);
|
|
|
|
// Token: 0x060009F0 RID: 2544
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
public static extern float PerlinNoise(float x, float y);
|
|
|
|
// Token: 0x060009F1 RID: 2545
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
public static extern ushort FloatToHalf(float val);
|
|
|
|
// Token: 0x060009F2 RID: 2546
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
public static extern float HalfToFloat(ushort val);
|
|
|
|
// Token: 0x060009F3 RID: 2547 RVA: 0x0000EB04 File Offset: 0x0000CD04
|
|
public static float Sin(float f)
|
|
{
|
|
return (float)Math.Sin((double)f);
|
|
}
|
|
|
|
// Token: 0x060009F4 RID: 2548 RVA: 0x0000EB24 File Offset: 0x0000CD24
|
|
public static float Cos(float f)
|
|
{
|
|
return (float)Math.Cos((double)f);
|
|
}
|
|
|
|
// Token: 0x060009F5 RID: 2549 RVA: 0x0000EB44 File Offset: 0x0000CD44
|
|
public static float Tan(float f)
|
|
{
|
|
return (float)Math.Tan((double)f);
|
|
}
|
|
|
|
// Token: 0x060009F6 RID: 2550 RVA: 0x0000EB64 File Offset: 0x0000CD64
|
|
public static float Asin(float f)
|
|
{
|
|
return (float)Math.Asin((double)f);
|
|
}
|
|
|
|
// Token: 0x060009F7 RID: 2551 RVA: 0x0000EB84 File Offset: 0x0000CD84
|
|
public static float Acos(float f)
|
|
{
|
|
return (float)Math.Acos((double)f);
|
|
}
|
|
|
|
// Token: 0x060009F8 RID: 2552 RVA: 0x0000EBA4 File Offset: 0x0000CDA4
|
|
public static float Atan(float f)
|
|
{
|
|
return (float)Math.Atan((double)f);
|
|
}
|
|
|
|
// Token: 0x060009F9 RID: 2553 RVA: 0x0000EBC4 File Offset: 0x0000CDC4
|
|
public static float Atan2(float y, float x)
|
|
{
|
|
return (float)Math.Atan2((double)y, (double)x);
|
|
}
|
|
|
|
// Token: 0x060009FA RID: 2554 RVA: 0x0000EBE4 File Offset: 0x0000CDE4
|
|
public static float Sqrt(float f)
|
|
{
|
|
return (float)Math.Sqrt((double)f);
|
|
}
|
|
|
|
// Token: 0x060009FB RID: 2555 RVA: 0x0000EC04 File Offset: 0x0000CE04
|
|
public static float Abs(float f)
|
|
{
|
|
return Math.Abs(f);
|
|
}
|
|
|
|
// Token: 0x060009FC RID: 2556 RVA: 0x0000EC20 File Offset: 0x0000CE20
|
|
public static int Abs(int value)
|
|
{
|
|
return Math.Abs(value);
|
|
}
|
|
|
|
// Token: 0x060009FD RID: 2557 RVA: 0x0000EC3C File Offset: 0x0000CE3C
|
|
public static float Min(float a, float b)
|
|
{
|
|
return (a >= b) ? b : a;
|
|
}
|
|
|
|
// Token: 0x060009FE RID: 2558 RVA: 0x0000EC60 File Offset: 0x0000CE60
|
|
public static float Min(params float[] values)
|
|
{
|
|
int num = values.Length;
|
|
float num2;
|
|
if (num == 0)
|
|
{
|
|
num2 = 0f;
|
|
}
|
|
else
|
|
{
|
|
float num3 = values[0];
|
|
for (int i = 1; i < num; i++)
|
|
{
|
|
if (values[i] < num3)
|
|
{
|
|
num3 = values[i];
|
|
}
|
|
}
|
|
num2 = num3;
|
|
}
|
|
return num2;
|
|
}
|
|
|
|
// Token: 0x060009FF RID: 2559 RVA: 0x0000ECB0 File Offset: 0x0000CEB0
|
|
public static int Min(int a, int b)
|
|
{
|
|
return (a >= b) ? b : a;
|
|
}
|
|
|
|
// Token: 0x06000A00 RID: 2560 RVA: 0x0000ECD4 File Offset: 0x0000CED4
|
|
public static int Min(params int[] values)
|
|
{
|
|
int num = values.Length;
|
|
int num2;
|
|
if (num == 0)
|
|
{
|
|
num2 = 0;
|
|
}
|
|
else
|
|
{
|
|
int num3 = values[0];
|
|
for (int i = 1; i < num; i++)
|
|
{
|
|
if (values[i] < num3)
|
|
{
|
|
num3 = values[i];
|
|
}
|
|
}
|
|
num2 = num3;
|
|
}
|
|
return num2;
|
|
}
|
|
|
|
// Token: 0x06000A01 RID: 2561 RVA: 0x0000ED20 File Offset: 0x0000CF20
|
|
public static float Max(float a, float b)
|
|
{
|
|
return (a <= b) ? b : a;
|
|
}
|
|
|
|
// Token: 0x06000A02 RID: 2562 RVA: 0x0000ED44 File Offset: 0x0000CF44
|
|
public static float Max(params float[] values)
|
|
{
|
|
int num = values.Length;
|
|
float num2;
|
|
if (num == 0)
|
|
{
|
|
num2 = 0f;
|
|
}
|
|
else
|
|
{
|
|
float num3 = values[0];
|
|
for (int i = 1; i < num; i++)
|
|
{
|
|
if (values[i] > num3)
|
|
{
|
|
num3 = values[i];
|
|
}
|
|
}
|
|
num2 = num3;
|
|
}
|
|
return num2;
|
|
}
|
|
|
|
// Token: 0x06000A03 RID: 2563 RVA: 0x0000ED94 File Offset: 0x0000CF94
|
|
public static int Max(int a, int b)
|
|
{
|
|
return (a <= b) ? b : a;
|
|
}
|
|
|
|
// Token: 0x06000A04 RID: 2564 RVA: 0x0000EDB8 File Offset: 0x0000CFB8
|
|
public static int Max(params int[] values)
|
|
{
|
|
int num = values.Length;
|
|
int num2;
|
|
if (num == 0)
|
|
{
|
|
num2 = 0;
|
|
}
|
|
else
|
|
{
|
|
int num3 = values[0];
|
|
for (int i = 1; i < num; i++)
|
|
{
|
|
if (values[i] > num3)
|
|
{
|
|
num3 = values[i];
|
|
}
|
|
}
|
|
num2 = num3;
|
|
}
|
|
return num2;
|
|
}
|
|
|
|
// Token: 0x06000A05 RID: 2565 RVA: 0x0000EE04 File Offset: 0x0000D004
|
|
public static float Pow(float f, float p)
|
|
{
|
|
return (float)Math.Pow((double)f, (double)p);
|
|
}
|
|
|
|
// Token: 0x06000A06 RID: 2566 RVA: 0x0000EE24 File Offset: 0x0000D024
|
|
public static float Exp(float power)
|
|
{
|
|
return (float)Math.Exp((double)power);
|
|
}
|
|
|
|
// Token: 0x06000A07 RID: 2567 RVA: 0x0000EE44 File Offset: 0x0000D044
|
|
public static float Log(float f, float p)
|
|
{
|
|
return (float)Math.Log((double)f, (double)p);
|
|
}
|
|
|
|
// Token: 0x06000A08 RID: 2568 RVA: 0x0000EE64 File Offset: 0x0000D064
|
|
public static float Log(float f)
|
|
{
|
|
return (float)Math.Log((double)f);
|
|
}
|
|
|
|
// Token: 0x06000A09 RID: 2569 RVA: 0x0000EE84 File Offset: 0x0000D084
|
|
public static float Log10(float f)
|
|
{
|
|
return (float)Math.Log10((double)f);
|
|
}
|
|
|
|
// Token: 0x06000A0A RID: 2570 RVA: 0x0000EEA4 File Offset: 0x0000D0A4
|
|
public static float Ceil(float f)
|
|
{
|
|
return (float)Math.Ceiling((double)f);
|
|
}
|
|
|
|
// Token: 0x06000A0B RID: 2571 RVA: 0x0000EEC4 File Offset: 0x0000D0C4
|
|
public static float Floor(float f)
|
|
{
|
|
return (float)Math.Floor((double)f);
|
|
}
|
|
|
|
// Token: 0x06000A0C RID: 2572 RVA: 0x0000EEE4 File Offset: 0x0000D0E4
|
|
public static float Round(float f)
|
|
{
|
|
return (float)Math.Round((double)f);
|
|
}
|
|
|
|
// Token: 0x06000A0D RID: 2573 RVA: 0x0000EF04 File Offset: 0x0000D104
|
|
public static int CeilToInt(float f)
|
|
{
|
|
return (int)Math.Ceiling((double)f);
|
|
}
|
|
|
|
// Token: 0x06000A0E RID: 2574 RVA: 0x0000EF24 File Offset: 0x0000D124
|
|
public static int FloorToInt(float f)
|
|
{
|
|
return (int)Math.Floor((double)f);
|
|
}
|
|
|
|
// Token: 0x06000A0F RID: 2575 RVA: 0x0000EF44 File Offset: 0x0000D144
|
|
public static int RoundToInt(float f)
|
|
{
|
|
return (int)Math.Round((double)f);
|
|
}
|
|
|
|
// Token: 0x06000A10 RID: 2576 RVA: 0x0000EF64 File Offset: 0x0000D164
|
|
public static float Sign(float f)
|
|
{
|
|
return (f < 0f) ? (-1f) : 1f;
|
|
}
|
|
|
|
// Token: 0x06000A11 RID: 2577 RVA: 0x0000EF94 File Offset: 0x0000D194
|
|
public static float Clamp(float value, float min, float max)
|
|
{
|
|
if (value < min)
|
|
{
|
|
value = min;
|
|
}
|
|
else if (value > max)
|
|
{
|
|
value = max;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
// Token: 0x06000A12 RID: 2578 RVA: 0x0000EFC4 File Offset: 0x0000D1C4
|
|
public static int Clamp(int value, int min, int max)
|
|
{
|
|
if (value < min)
|
|
{
|
|
value = min;
|
|
}
|
|
else if (value > max)
|
|
{
|
|
value = max;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
// Token: 0x06000A13 RID: 2579 RVA: 0x0000EFF4 File Offset: 0x0000D1F4
|
|
public static float Clamp01(float value)
|
|
{
|
|
float num;
|
|
if (value < 0f)
|
|
{
|
|
num = 0f;
|
|
}
|
|
else if (value > 1f)
|
|
{
|
|
num = 1f;
|
|
}
|
|
else
|
|
{
|
|
num = value;
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x06000A14 RID: 2580 RVA: 0x0000F038 File Offset: 0x0000D238
|
|
public static float Lerp(float a, float b, float t)
|
|
{
|
|
return a + (b - a) * Mathf.Clamp01(t);
|
|
}
|
|
|
|
// Token: 0x06000A15 RID: 2581 RVA: 0x0000F05C File Offset: 0x0000D25C
|
|
public static float LerpUnclamped(float a, float b, float t)
|
|
{
|
|
return a + (b - a) * t;
|
|
}
|
|
|
|
// Token: 0x06000A16 RID: 2582 RVA: 0x0000F078 File Offset: 0x0000D278
|
|
public static float LerpAngle(float a, float b, float t)
|
|
{
|
|
float num = Mathf.Repeat(b - a, 360f);
|
|
if (num > 180f)
|
|
{
|
|
num -= 360f;
|
|
}
|
|
return a + num * Mathf.Clamp01(t);
|
|
}
|
|
|
|
// Token: 0x06000A17 RID: 2583 RVA: 0x0000F0B8 File Offset: 0x0000D2B8
|
|
public static float MoveTowards(float current, float target, float maxDelta)
|
|
{
|
|
float num;
|
|
if (Mathf.Abs(target - current) <= maxDelta)
|
|
{
|
|
num = target;
|
|
}
|
|
else
|
|
{
|
|
num = current + Mathf.Sign(target - current) * maxDelta;
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x06000A18 RID: 2584 RVA: 0x0000F0F0 File Offset: 0x0000D2F0
|
|
public static float MoveTowardsAngle(float current, float target, float maxDelta)
|
|
{
|
|
float num = Mathf.DeltaAngle(current, target);
|
|
float num2;
|
|
if (-maxDelta < num && num < maxDelta)
|
|
{
|
|
num2 = target;
|
|
}
|
|
else
|
|
{
|
|
target = current + num;
|
|
num2 = Mathf.MoveTowards(current, target, maxDelta);
|
|
}
|
|
return num2;
|
|
}
|
|
|
|
// Token: 0x06000A19 RID: 2585 RVA: 0x0000F130 File Offset: 0x0000D330
|
|
public static float SmoothStep(float from, float to, float t)
|
|
{
|
|
t = Mathf.Clamp01(t);
|
|
t = -2f * t * t * t + 3f * t * t;
|
|
return to * t + from * (1f - t);
|
|
}
|
|
|
|
// Token: 0x06000A1A RID: 2586 RVA: 0x0000F174 File Offset: 0x0000D374
|
|
public static float Gamma(float value, float absmax, float gamma)
|
|
{
|
|
bool flag = false;
|
|
if (value < 0f)
|
|
{
|
|
flag = true;
|
|
}
|
|
float num = Mathf.Abs(value);
|
|
float num2;
|
|
if (num > absmax)
|
|
{
|
|
num2 = ((!flag) ? num : (-num));
|
|
}
|
|
else
|
|
{
|
|
float num3 = Mathf.Pow(num / absmax, gamma) * absmax;
|
|
num2 = ((!flag) ? num3 : (-num3));
|
|
}
|
|
return num2;
|
|
}
|
|
|
|
// Token: 0x06000A1B RID: 2587 RVA: 0x0000F1D4 File Offset: 0x0000D3D4
|
|
public static bool Approximately(float a, float b)
|
|
{
|
|
return Mathf.Abs(b - a) < Mathf.Max(1E-06f * Mathf.Max(Mathf.Abs(a), Mathf.Abs(b)), Mathf.Epsilon * 8f);
|
|
}
|
|
|
|
// Token: 0x06000A1C RID: 2588 RVA: 0x0000F21C File Offset: 0x0000D41C
|
|
[ExcludeFromDocs]
|
|
public static float SmoothDamp(float current, float target, ref float currentVelocity, float smoothTime, float maxSpeed)
|
|
{
|
|
float deltaTime = Time.deltaTime;
|
|
return Mathf.SmoothDamp(current, target, ref currentVelocity, smoothTime, maxSpeed, deltaTime);
|
|
}
|
|
|
|
// Token: 0x06000A1D RID: 2589 RVA: 0x0000F244 File Offset: 0x0000D444
|
|
[ExcludeFromDocs]
|
|
public static float SmoothDamp(float current, float target, ref float currentVelocity, float smoothTime)
|
|
{
|
|
float deltaTime = Time.deltaTime;
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Mathf.SmoothDamp(current, target, ref currentVelocity, smoothTime, positiveInfinity, deltaTime);
|
|
}
|
|
|
|
// Token: 0x06000A1E RID: 2590 RVA: 0x0000F270 File Offset: 0x0000D470
|
|
public static float SmoothDamp(float current, float target, ref float currentVelocity, float smoothTime, [DefaultValue("Mathf.Infinity")] float maxSpeed, [DefaultValue("Time.deltaTime")] float deltaTime)
|
|
{
|
|
smoothTime = Mathf.Max(0.0001f, smoothTime);
|
|
float num = 2f / smoothTime;
|
|
float num2 = num * deltaTime;
|
|
float num3 = 1f / (1f + num2 + 0.48f * num2 * num2 + 0.235f * num2 * num2 * num2);
|
|
float num4 = current - target;
|
|
float num5 = target;
|
|
float num6 = maxSpeed * smoothTime;
|
|
num4 = Mathf.Clamp(num4, -num6, num6);
|
|
target = current - num4;
|
|
float num7 = (currentVelocity + num * num4) * deltaTime;
|
|
currentVelocity = (currentVelocity - num * num7) * num3;
|
|
float num8 = target + (num4 + num7) * num3;
|
|
if (num5 - current > 0f == num8 > num5)
|
|
{
|
|
num8 = num5;
|
|
currentVelocity = (num8 - num5) / deltaTime;
|
|
}
|
|
return num8;
|
|
}
|
|
|
|
// Token: 0x06000A1F RID: 2591 RVA: 0x0000F32C File Offset: 0x0000D52C
|
|
[ExcludeFromDocs]
|
|
public static float SmoothDampAngle(float current, float target, ref float currentVelocity, float smoothTime, float maxSpeed)
|
|
{
|
|
float deltaTime = Time.deltaTime;
|
|
return Mathf.SmoothDampAngle(current, target, ref currentVelocity, smoothTime, maxSpeed, deltaTime);
|
|
}
|
|
|
|
// Token: 0x06000A20 RID: 2592 RVA: 0x0000F354 File Offset: 0x0000D554
|
|
[ExcludeFromDocs]
|
|
public static float SmoothDampAngle(float current, float target, ref float currentVelocity, float smoothTime)
|
|
{
|
|
float deltaTime = Time.deltaTime;
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Mathf.SmoothDampAngle(current, target, ref currentVelocity, smoothTime, positiveInfinity, deltaTime);
|
|
}
|
|
|
|
// Token: 0x06000A21 RID: 2593 RVA: 0x0000F380 File Offset: 0x0000D580
|
|
public static float SmoothDampAngle(float current, float target, ref float currentVelocity, float smoothTime, [DefaultValue("Mathf.Infinity")] float maxSpeed, [DefaultValue("Time.deltaTime")] float deltaTime)
|
|
{
|
|
target = current + Mathf.DeltaAngle(current, target);
|
|
return Mathf.SmoothDamp(current, target, ref currentVelocity, smoothTime, maxSpeed, deltaTime);
|
|
}
|
|
|
|
// Token: 0x06000A22 RID: 2594 RVA: 0x0000F3B0 File Offset: 0x0000D5B0
|
|
public static float Repeat(float t, float length)
|
|
{
|
|
return Mathf.Clamp(t - Mathf.Floor(t / length) * length, 0f, length);
|
|
}
|
|
|
|
// Token: 0x06000A23 RID: 2595 RVA: 0x0000F3DC File Offset: 0x0000D5DC
|
|
public static float PingPong(float t, float length)
|
|
{
|
|
t = Mathf.Repeat(t, length * 2f);
|
|
return length - Mathf.Abs(t - length);
|
|
}
|
|
|
|
// Token: 0x06000A24 RID: 2596 RVA: 0x0000F40C File Offset: 0x0000D60C
|
|
public static float InverseLerp(float a, float b, float value)
|
|
{
|
|
float num;
|
|
if (a != b)
|
|
{
|
|
num = Mathf.Clamp01((value - a) / (b - a));
|
|
}
|
|
else
|
|
{
|
|
num = 0f;
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x06000A25 RID: 2597 RVA: 0x0000F440 File Offset: 0x0000D640
|
|
public static float DeltaAngle(float current, float target)
|
|
{
|
|
float num = Mathf.Repeat(target - current, 360f);
|
|
if (num > 180f)
|
|
{
|
|
num -= 360f;
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x06000A26 RID: 2598 RVA: 0x0000F478 File Offset: 0x0000D678
|
|
internal static bool LineIntersection(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, ref Vector2 result)
|
|
{
|
|
float num = p2.x - p1.x;
|
|
float num2 = p2.y - p1.y;
|
|
float num3 = p4.x - p3.x;
|
|
float num4 = p4.y - p3.y;
|
|
float num5 = num * num4 - num2 * num3;
|
|
bool flag;
|
|
if (num5 == 0f)
|
|
{
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
float num6 = p3.x - p1.x;
|
|
float num7 = p3.y - p1.y;
|
|
float num8 = (num6 * num4 - num7 * num3) / num5;
|
|
result = new Vector2(p1.x + num8 * num, p1.y + num8 * num2);
|
|
flag = true;
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x06000A27 RID: 2599 RVA: 0x0000F540 File Offset: 0x0000D740
|
|
internal static bool LineSegmentIntersection(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, ref Vector2 result)
|
|
{
|
|
float num = p2.x - p1.x;
|
|
float num2 = p2.y - p1.y;
|
|
float num3 = p4.x - p3.x;
|
|
float num4 = p4.y - p3.y;
|
|
float num5 = num * num4 - num2 * num3;
|
|
bool flag;
|
|
if (num5 == 0f)
|
|
{
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
float num6 = p3.x - p1.x;
|
|
float num7 = p3.y - p1.y;
|
|
float num8 = (num6 * num4 - num7 * num3) / num5;
|
|
if (num8 < 0f || num8 > 1f)
|
|
{
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
float num9 = (num6 * num2 - num7 * num) / num5;
|
|
if (num9 < 0f || num9 > 1f)
|
|
{
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
result = new Vector2(p1.x + num8 * num, p1.y + num8 * num2);
|
|
flag = true;
|
|
}
|
|
}
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x06000A28 RID: 2600 RVA: 0x0000F658 File Offset: 0x0000D858
|
|
internal static long RandomToLong(Random r)
|
|
{
|
|
byte[] array = new byte[8];
|
|
r.NextBytes(array);
|
|
return (long)(BitConverter.ToUInt64(array, 0) & 9223372036854775807UL);
|
|
}
|
|
|
|
// Token: 0x040000F9 RID: 249
|
|
public const float PI = 3.1415927f;
|
|
|
|
// Token: 0x040000FA RID: 250
|
|
public const float Infinity = float.PositiveInfinity;
|
|
|
|
// Token: 0x040000FB RID: 251
|
|
public const float NegativeInfinity = float.NegativeInfinity;
|
|
|
|
// Token: 0x040000FC RID: 252
|
|
public const float Deg2Rad = 0.017453292f;
|
|
|
|
// Token: 0x040000FD RID: 253
|
|
public const float Rad2Deg = 57.29578f;
|
|
|
|
// Token: 0x040000FE RID: 254
|
|
public static readonly float Epsilon = ((!MathfInternal.IsFlushToZeroEnabled) ? MathfInternal.FloatMinDenormal : MathfInternal.FloatMinNormal);
|
|
}
|
|
}
|