niko
426 lines
11 KiB
C#
426 lines
11 KiB
C#
using System;
|
|
using UnityEngine.Scripting;
|
|
|
|
namespace UnityEngine
|
|
{
|
|
// Token: 0x0200048F RID: 1167
|
|
[UsedByNativeCode]
|
|
public struct Vector4
|
|
{
|
|
// Token: 0x06003A4D RID: 14925 RVA: 0x00066208 File Offset: 0x00064408
|
|
public Vector4(float x, float y, float z, float w)
|
|
{
|
|
this.x = x;
|
|
this.y = y;
|
|
this.z = z;
|
|
this.w = w;
|
|
}
|
|
|
|
// Token: 0x06003A4E RID: 14926 RVA: 0x00066228 File Offset: 0x00064428
|
|
public Vector4(float x, float y, float z)
|
|
{
|
|
this.x = x;
|
|
this.y = y;
|
|
this.z = z;
|
|
this.w = 0f;
|
|
}
|
|
|
|
// Token: 0x06003A4F RID: 14927 RVA: 0x0006624C File Offset: 0x0006444C
|
|
public Vector4(float x, float y)
|
|
{
|
|
this.x = x;
|
|
this.y = y;
|
|
this.z = 0f;
|
|
this.w = 0f;
|
|
}
|
|
|
|
// Token: 0x17000D4B RID: 3403
|
|
public float this[int index]
|
|
{
|
|
get
|
|
{
|
|
float num;
|
|
switch (index)
|
|
{
|
|
case 0:
|
|
num = this.x;
|
|
break;
|
|
case 1:
|
|
num = this.y;
|
|
break;
|
|
case 2:
|
|
num = this.z;
|
|
break;
|
|
case 3:
|
|
num = this.w;
|
|
break;
|
|
default:
|
|
throw new IndexOutOfRangeException("Invalid Vector4 index!");
|
|
}
|
|
return num;
|
|
}
|
|
set
|
|
{
|
|
switch (index)
|
|
{
|
|
case 0:
|
|
this.x = value;
|
|
break;
|
|
case 1:
|
|
this.y = value;
|
|
break;
|
|
case 2:
|
|
this.z = value;
|
|
break;
|
|
case 3:
|
|
this.w = value;
|
|
break;
|
|
default:
|
|
throw new IndexOutOfRangeException("Invalid Vector4 index!");
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06003A52 RID: 14930 RVA: 0x00066340 File Offset: 0x00064540
|
|
public void Set(float newX, float newY, float newZ, float newW)
|
|
{
|
|
this.x = newX;
|
|
this.y = newY;
|
|
this.z = newZ;
|
|
this.w = newW;
|
|
}
|
|
|
|
// Token: 0x06003A53 RID: 14931 RVA: 0x00066360 File Offset: 0x00064560
|
|
public static Vector4 Lerp(Vector4 a, Vector4 b, float t)
|
|
{
|
|
t = Mathf.Clamp01(t);
|
|
return new Vector4(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t, a.w + (b.w - a.w) * t);
|
|
}
|
|
|
|
// Token: 0x06003A54 RID: 14932 RVA: 0x000663E8 File Offset: 0x000645E8
|
|
public static Vector4 LerpUnclamped(Vector4 a, Vector4 b, float t)
|
|
{
|
|
return new Vector4(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t, a.w + (b.w - a.w) * t);
|
|
}
|
|
|
|
// Token: 0x06003A55 RID: 14933 RVA: 0x00066468 File Offset: 0x00064668
|
|
public static Vector4 MoveTowards(Vector4 current, Vector4 target, float maxDistanceDelta)
|
|
{
|
|
Vector4 vector = target - current;
|
|
float magnitude = vector.magnitude;
|
|
Vector4 vector2;
|
|
if (magnitude <= maxDistanceDelta || magnitude == 0f)
|
|
{
|
|
vector2 = target;
|
|
}
|
|
else
|
|
{
|
|
vector2 = current + vector / magnitude * maxDistanceDelta;
|
|
}
|
|
return vector2;
|
|
}
|
|
|
|
// Token: 0x06003A56 RID: 14934 RVA: 0x000664BC File Offset: 0x000646BC
|
|
public static Vector4 Scale(Vector4 a, Vector4 b)
|
|
{
|
|
return new Vector4(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
|
|
}
|
|
|
|
// Token: 0x06003A57 RID: 14935 RVA: 0x00066514 File Offset: 0x00064714
|
|
public void Scale(Vector4 scale)
|
|
{
|
|
this.x *= scale.x;
|
|
this.y *= scale.y;
|
|
this.z *= scale.z;
|
|
this.w *= scale.w;
|
|
}
|
|
|
|
// Token: 0x06003A58 RID: 14936 RVA: 0x00066574 File Offset: 0x00064774
|
|
public override int GetHashCode()
|
|
{
|
|
return this.x.GetHashCode() ^ (this.y.GetHashCode() << 2) ^ (this.z.GetHashCode() >> 2) ^ (this.w.GetHashCode() >> 1);
|
|
}
|
|
|
|
// Token: 0x06003A59 RID: 14937 RVA: 0x000665D8 File Offset: 0x000647D8
|
|
public override bool Equals(object other)
|
|
{
|
|
bool flag;
|
|
if (!(other is Vector4))
|
|
{
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
Vector4 vector = (Vector4)other;
|
|
flag = this.x.Equals(vector.x) && this.y.Equals(vector.y) && this.z.Equals(vector.z) && this.w.Equals(vector.w);
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x06003A5A RID: 14938 RVA: 0x00066660 File Offset: 0x00064860
|
|
public static Vector4 Normalize(Vector4 a)
|
|
{
|
|
float num = Vector4.Magnitude(a);
|
|
Vector4 vector;
|
|
if (num > 1E-05f)
|
|
{
|
|
vector = a / num;
|
|
}
|
|
else
|
|
{
|
|
vector = Vector4.zero;
|
|
}
|
|
return vector;
|
|
}
|
|
|
|
// Token: 0x06003A5B RID: 14939 RVA: 0x0006669C File Offset: 0x0006489C
|
|
public void Normalize()
|
|
{
|
|
float num = Vector4.Magnitude(this);
|
|
if (num > 1E-05f)
|
|
{
|
|
this /= num;
|
|
}
|
|
else
|
|
{
|
|
this = Vector4.zero;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000D4C RID: 3404
|
|
// (get) Token: 0x06003A5C RID: 14940 RVA: 0x000666E4 File Offset: 0x000648E4
|
|
public Vector4 normalized
|
|
{
|
|
get
|
|
{
|
|
return Vector4.Normalize(this);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06003A5D RID: 14941 RVA: 0x00066704 File Offset: 0x00064904
|
|
public static float Dot(Vector4 a, Vector4 b)
|
|
{
|
|
return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
|
|
}
|
|
|
|
// Token: 0x06003A5E RID: 14942 RVA: 0x00066758 File Offset: 0x00064958
|
|
public static Vector4 Project(Vector4 a, Vector4 b)
|
|
{
|
|
return b * Vector4.Dot(a, b) / Vector4.Dot(b, b);
|
|
}
|
|
|
|
// Token: 0x06003A5F RID: 14943 RVA: 0x00066788 File Offset: 0x00064988
|
|
public static float Distance(Vector4 a, Vector4 b)
|
|
{
|
|
return Vector4.Magnitude(a - b);
|
|
}
|
|
|
|
// Token: 0x06003A60 RID: 14944 RVA: 0x000667AC File Offset: 0x000649AC
|
|
public static float Magnitude(Vector4 a)
|
|
{
|
|
return Mathf.Sqrt(Vector4.Dot(a, a));
|
|
}
|
|
|
|
// Token: 0x17000D4D RID: 3405
|
|
// (get) Token: 0x06003A61 RID: 14945 RVA: 0x000667D0 File Offset: 0x000649D0
|
|
public float magnitude
|
|
{
|
|
get
|
|
{
|
|
return Mathf.Sqrt(Vector4.Dot(this, this));
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000D4E RID: 3406
|
|
// (get) Token: 0x06003A62 RID: 14946 RVA: 0x000667FC File Offset: 0x000649FC
|
|
public float sqrMagnitude
|
|
{
|
|
get
|
|
{
|
|
return Vector4.Dot(this, this);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06003A63 RID: 14947 RVA: 0x00066824 File Offset: 0x00064A24
|
|
public static Vector4 Min(Vector4 lhs, Vector4 rhs)
|
|
{
|
|
return new Vector4(Mathf.Min(lhs.x, rhs.x), Mathf.Min(lhs.y, rhs.y), Mathf.Min(lhs.z, rhs.z), Mathf.Min(lhs.w, rhs.w));
|
|
}
|
|
|
|
// Token: 0x06003A64 RID: 14948 RVA: 0x0006688C File Offset: 0x00064A8C
|
|
public static Vector4 Max(Vector4 lhs, Vector4 rhs)
|
|
{
|
|
return new Vector4(Mathf.Max(lhs.x, rhs.x), Mathf.Max(lhs.y, rhs.y), Mathf.Max(lhs.z, rhs.z), Mathf.Max(lhs.w, rhs.w));
|
|
}
|
|
|
|
// Token: 0x17000D4F RID: 3407
|
|
// (get) Token: 0x06003A65 RID: 14949 RVA: 0x000668F4 File Offset: 0x00064AF4
|
|
public static Vector4 zero
|
|
{
|
|
get
|
|
{
|
|
return Vector4.zeroVector;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000D50 RID: 3408
|
|
// (get) Token: 0x06003A66 RID: 14950 RVA: 0x00066910 File Offset: 0x00064B10
|
|
public static Vector4 one
|
|
{
|
|
get
|
|
{
|
|
return Vector4.oneVector;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000D51 RID: 3409
|
|
// (get) Token: 0x06003A67 RID: 14951 RVA: 0x0006692C File Offset: 0x00064B2C
|
|
public static Vector4 positiveInfinity
|
|
{
|
|
get
|
|
{
|
|
return Vector4.positiveInfinityVector;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000D52 RID: 3410
|
|
// (get) Token: 0x06003A68 RID: 14952 RVA: 0x00066948 File Offset: 0x00064B48
|
|
public static Vector4 negativeInfinity
|
|
{
|
|
get
|
|
{
|
|
return Vector4.negativeInfinityVector;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06003A69 RID: 14953 RVA: 0x00066964 File Offset: 0x00064B64
|
|
public static Vector4 operator +(Vector4 a, Vector4 b)
|
|
{
|
|
return new Vector4(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
|
|
}
|
|
|
|
// Token: 0x06003A6A RID: 14954 RVA: 0x000669BC File Offset: 0x00064BBC
|
|
public static Vector4 operator -(Vector4 a, Vector4 b)
|
|
{
|
|
return new Vector4(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w);
|
|
}
|
|
|
|
// Token: 0x06003A6B RID: 14955 RVA: 0x00066A14 File Offset: 0x00064C14
|
|
public static Vector4 operator -(Vector4 a)
|
|
{
|
|
return new Vector4(-a.x, -a.y, -a.z, -a.w);
|
|
}
|
|
|
|
// Token: 0x06003A6C RID: 14956 RVA: 0x00066A50 File Offset: 0x00064C50
|
|
public static Vector4 operator *(Vector4 a, float d)
|
|
{
|
|
return new Vector4(a.x * d, a.y * d, a.z * d, a.w * d);
|
|
}
|
|
|
|
// Token: 0x06003A6D RID: 14957 RVA: 0x00066A90 File Offset: 0x00064C90
|
|
public static Vector4 operator *(float d, Vector4 a)
|
|
{
|
|
return new Vector4(a.x * d, a.y * d, a.z * d, a.w * d);
|
|
}
|
|
|
|
// Token: 0x06003A6E RID: 14958 RVA: 0x00066AD0 File Offset: 0x00064CD0
|
|
public static Vector4 operator /(Vector4 a, float d)
|
|
{
|
|
return new Vector4(a.x / d, a.y / d, a.z / d, a.w / d);
|
|
}
|
|
|
|
// Token: 0x06003A6F RID: 14959 RVA: 0x00066B10 File Offset: 0x00064D10
|
|
public static bool operator ==(Vector4 lhs, Vector4 rhs)
|
|
{
|
|
return Vector4.SqrMagnitude(lhs - rhs) < 9.9999994E-11f;
|
|
}
|
|
|
|
// Token: 0x06003A70 RID: 14960 RVA: 0x00066B38 File Offset: 0x00064D38
|
|
public static bool operator !=(Vector4 lhs, Vector4 rhs)
|
|
{
|
|
return !(lhs == rhs);
|
|
}
|
|
|
|
// Token: 0x06003A71 RID: 14961 RVA: 0x00066B58 File Offset: 0x00064D58
|
|
public static implicit operator Vector4(Vector3 v)
|
|
{
|
|
return new Vector4(v.x, v.y, v.z, 0f);
|
|
}
|
|
|
|
// Token: 0x06003A72 RID: 14962 RVA: 0x00066B8C File Offset: 0x00064D8C
|
|
public static implicit operator Vector3(Vector4 v)
|
|
{
|
|
return new Vector3(v.x, v.y, v.z);
|
|
}
|
|
|
|
// Token: 0x06003A73 RID: 14963 RVA: 0x00066BBC File Offset: 0x00064DBC
|
|
public static implicit operator Vector4(Vector2 v)
|
|
{
|
|
return new Vector4(v.x, v.y, 0f, 0f);
|
|
}
|
|
|
|
// Token: 0x06003A74 RID: 14964 RVA: 0x00066BF0 File Offset: 0x00064DF0
|
|
public static implicit operator Vector2(Vector4 v)
|
|
{
|
|
return new Vector2(v.x, v.y);
|
|
}
|
|
|
|
// Token: 0x06003A75 RID: 14965 RVA: 0x00066C18 File Offset: 0x00064E18
|
|
public override string ToString()
|
|
{
|
|
return UnityString.Format("({0:F1}, {1:F1}, {2:F1}, {3:F1})", new object[] { this.x, this.y, this.z, this.w });
|
|
}
|
|
|
|
// Token: 0x06003A76 RID: 14966 RVA: 0x00066C78 File Offset: 0x00064E78
|
|
public string ToString(string format)
|
|
{
|
|
return UnityString.Format("({0}, {1}, {2}, {3})", new object[]
|
|
{
|
|
this.x.ToString(format),
|
|
this.y.ToString(format),
|
|
this.z.ToString(format),
|
|
this.w.ToString(format)
|
|
});
|
|
}
|
|
|
|
// Token: 0x06003A77 RID: 14967 RVA: 0x00066CDC File Offset: 0x00064EDC
|
|
public static float SqrMagnitude(Vector4 a)
|
|
{
|
|
return Vector4.Dot(a, a);
|
|
}
|
|
|
|
// Token: 0x06003A78 RID: 14968 RVA: 0x00066CF8 File Offset: 0x00064EF8
|
|
public float SqrMagnitude()
|
|
{
|
|
return Vector4.Dot(this, this);
|
|
}
|
|
|
|
// Token: 0x040011A6 RID: 4518
|
|
public const float kEpsilon = 1E-05f;
|
|
|
|
// Token: 0x040011A7 RID: 4519
|
|
public float x;
|
|
|
|
// Token: 0x040011A8 RID: 4520
|
|
public float y;
|
|
|
|
// Token: 0x040011A9 RID: 4521
|
|
public float z;
|
|
|
|
// Token: 0x040011AA RID: 4522
|
|
public float w;
|
|
|
|
// Token: 0x040011AB RID: 4523
|
|
private static readonly Vector4 zeroVector = new Vector4(0f, 0f, 0f, 0f);
|
|
|
|
// Token: 0x040011AC RID: 4524
|
|
private static readonly Vector4 oneVector = new Vector4(1f, 1f, 1f, 1f);
|
|
|
|
// Token: 0x040011AD RID: 4525
|
|
private static readonly Vector4 positiveInfinityVector = new Vector4(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity);
|
|
|
|
// Token: 0x040011AE RID: 4526
|
|
private static readonly Vector4 negativeInfinityVector = new Vector4(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity);
|
|
}
|
|
}
|