niko
559 lines
18 KiB
C#
559 lines
18 KiB
C#
using System;
|
|
using System.Runtime.CompilerServices;
|
|
using UnityEngine.Internal;
|
|
using UnityEngine.Scripting;
|
|
|
|
namespace UnityEngine
|
|
{
|
|
// Token: 0x02000084 RID: 132
|
|
[UsedByNativeCode]
|
|
public struct Quaternion
|
|
{
|
|
// Token: 0x06000955 RID: 2389 RVA: 0x0000C13C File Offset: 0x0000A33C
|
|
public Quaternion(float x, float y, float z, float w)
|
|
{
|
|
this.x = x;
|
|
this.y = y;
|
|
this.z = z;
|
|
this.w = w;
|
|
}
|
|
|
|
// Token: 0x06000956 RID: 2390 RVA: 0x0000C15C File Offset: 0x0000A35C
|
|
[ThreadAndSerializationSafe]
|
|
public static Quaternion AngleAxis(float angle, Vector3 axis)
|
|
{
|
|
Quaternion quaternion;
|
|
Quaternion.INTERNAL_CALL_AngleAxis(angle, ref axis, out quaternion);
|
|
return quaternion;
|
|
}
|
|
|
|
// Token: 0x06000957 RID: 2391
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_CALL_AngleAxis(float angle, ref Vector3 axis, out Quaternion value);
|
|
|
|
// Token: 0x06000958 RID: 2392 RVA: 0x0000C17C File Offset: 0x0000A37C
|
|
public void ToAngleAxis(out float angle, out Vector3 axis)
|
|
{
|
|
Quaternion.Internal_ToAxisAngleRad(this, out axis, out angle);
|
|
angle *= 57.29578f;
|
|
}
|
|
|
|
// Token: 0x06000959 RID: 2393 RVA: 0x0000C198 File Offset: 0x0000A398
|
|
public static Quaternion FromToRotation(Vector3 fromDirection, Vector3 toDirection)
|
|
{
|
|
Quaternion quaternion;
|
|
Quaternion.INTERNAL_CALL_FromToRotation(ref fromDirection, ref toDirection, out quaternion);
|
|
return quaternion;
|
|
}
|
|
|
|
// Token: 0x0600095A RID: 2394
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_CALL_FromToRotation(ref Vector3 fromDirection, ref Vector3 toDirection, out Quaternion value);
|
|
|
|
// Token: 0x0600095B RID: 2395 RVA: 0x0000C1BC File Offset: 0x0000A3BC
|
|
public void SetFromToRotation(Vector3 fromDirection, Vector3 toDirection)
|
|
{
|
|
this = Quaternion.FromToRotation(fromDirection, toDirection);
|
|
}
|
|
|
|
// Token: 0x0600095C RID: 2396 RVA: 0x0000C1CC File Offset: 0x0000A3CC
|
|
public static Quaternion LookRotation(Vector3 forward, [DefaultValue("Vector3.up")] Vector3 upwards)
|
|
{
|
|
Quaternion quaternion;
|
|
Quaternion.INTERNAL_CALL_LookRotation(ref forward, ref upwards, out quaternion);
|
|
return quaternion;
|
|
}
|
|
|
|
// Token: 0x0600095D RID: 2397 RVA: 0x0000C1F0 File Offset: 0x0000A3F0
|
|
[ExcludeFromDocs]
|
|
public static Quaternion LookRotation(Vector3 forward)
|
|
{
|
|
Vector3 up = Vector3.up;
|
|
Quaternion quaternion;
|
|
Quaternion.INTERNAL_CALL_LookRotation(ref forward, ref up, out quaternion);
|
|
return quaternion;
|
|
}
|
|
|
|
// Token: 0x0600095E RID: 2398
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_CALL_LookRotation(ref Vector3 forward, ref Vector3 upwards, out Quaternion value);
|
|
|
|
// Token: 0x0600095F RID: 2399 RVA: 0x0000C218 File Offset: 0x0000A418
|
|
public static Quaternion Slerp(Quaternion a, Quaternion b, float t)
|
|
{
|
|
Quaternion quaternion;
|
|
Quaternion.INTERNAL_CALL_Slerp(ref a, ref b, t, out quaternion);
|
|
return quaternion;
|
|
}
|
|
|
|
// Token: 0x06000960 RID: 2400
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_CALL_Slerp(ref Quaternion a, ref Quaternion b, float t, out Quaternion value);
|
|
|
|
// Token: 0x06000961 RID: 2401 RVA: 0x0000C23C File Offset: 0x0000A43C
|
|
public static Quaternion SlerpUnclamped(Quaternion a, Quaternion b, float t)
|
|
{
|
|
Quaternion quaternion;
|
|
Quaternion.INTERNAL_CALL_SlerpUnclamped(ref a, ref b, t, out quaternion);
|
|
return quaternion;
|
|
}
|
|
|
|
// Token: 0x06000962 RID: 2402
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_CALL_SlerpUnclamped(ref Quaternion a, ref Quaternion b, float t, out Quaternion value);
|
|
|
|
// Token: 0x06000963 RID: 2403 RVA: 0x0000C260 File Offset: 0x0000A460
|
|
public static Quaternion Lerp(Quaternion a, Quaternion b, float t)
|
|
{
|
|
Quaternion quaternion;
|
|
Quaternion.INTERNAL_CALL_Lerp(ref a, ref b, t, out quaternion);
|
|
return quaternion;
|
|
}
|
|
|
|
// Token: 0x06000964 RID: 2404
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_CALL_Lerp(ref Quaternion a, ref Quaternion b, float t, out Quaternion value);
|
|
|
|
// Token: 0x06000965 RID: 2405 RVA: 0x0000C284 File Offset: 0x0000A484
|
|
public static Quaternion LerpUnclamped(Quaternion a, Quaternion b, float t)
|
|
{
|
|
Quaternion quaternion;
|
|
Quaternion.INTERNAL_CALL_LerpUnclamped(ref a, ref b, t, out quaternion);
|
|
return quaternion;
|
|
}
|
|
|
|
// Token: 0x06000966 RID: 2406
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_CALL_LerpUnclamped(ref Quaternion a, ref Quaternion b, float t, out Quaternion value);
|
|
|
|
// Token: 0x06000967 RID: 2407 RVA: 0x0000C2A8 File Offset: 0x0000A4A8
|
|
public static Quaternion RotateTowards(Quaternion from, Quaternion to, float maxDegreesDelta)
|
|
{
|
|
float num = Quaternion.Angle(from, to);
|
|
Quaternion quaternion;
|
|
if (num == 0f)
|
|
{
|
|
quaternion = to;
|
|
}
|
|
else
|
|
{
|
|
float num2 = Mathf.Min(1f, maxDegreesDelta / num);
|
|
quaternion = Quaternion.SlerpUnclamped(from, to, num2);
|
|
}
|
|
return quaternion;
|
|
}
|
|
|
|
// Token: 0x06000968 RID: 2408 RVA: 0x0000C2F0 File Offset: 0x0000A4F0
|
|
public static Quaternion Inverse(Quaternion rotation)
|
|
{
|
|
Quaternion quaternion;
|
|
Quaternion.INTERNAL_CALL_Inverse(ref rotation, out quaternion);
|
|
return quaternion;
|
|
}
|
|
|
|
// Token: 0x06000969 RID: 2409
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_CALL_Inverse(ref Quaternion rotation, out Quaternion value);
|
|
|
|
// Token: 0x17000241 RID: 577
|
|
// (get) Token: 0x0600096A RID: 2410 RVA: 0x0000C310 File Offset: 0x0000A510
|
|
// (set) Token: 0x0600096B RID: 2411 RVA: 0x0000C340 File Offset: 0x0000A540
|
|
public Vector3 eulerAngles
|
|
{
|
|
get
|
|
{
|
|
return Quaternion.Internal_MakePositive(Quaternion.Internal_ToEulerRad(this) * 57.29578f);
|
|
}
|
|
set
|
|
{
|
|
this = Quaternion.Internal_FromEulerRad(value * 0.017453292f);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600096C RID: 2412 RVA: 0x0000C35C File Offset: 0x0000A55C
|
|
public static Quaternion Euler(float x, float y, float z)
|
|
{
|
|
return Quaternion.Internal_FromEulerRad(new Vector3(x, y, z) * 0.017453292f);
|
|
}
|
|
|
|
// Token: 0x0600096D RID: 2413 RVA: 0x0000C388 File Offset: 0x0000A588
|
|
public static Quaternion Euler(Vector3 euler)
|
|
{
|
|
return Quaternion.Internal_FromEulerRad(euler * 0.017453292f);
|
|
}
|
|
|
|
// Token: 0x0600096E RID: 2414 RVA: 0x0000C3B0 File Offset: 0x0000A5B0
|
|
private static Vector3 Internal_ToEulerRad(Quaternion rotation)
|
|
{
|
|
Vector3 vector;
|
|
Quaternion.INTERNAL_CALL_Internal_ToEulerRad(ref rotation, out vector);
|
|
return vector;
|
|
}
|
|
|
|
// Token: 0x0600096F RID: 2415
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_CALL_Internal_ToEulerRad(ref Quaternion rotation, out Vector3 value);
|
|
|
|
// Token: 0x06000970 RID: 2416 RVA: 0x0000C3D0 File Offset: 0x0000A5D0
|
|
private static Quaternion Internal_FromEulerRad(Vector3 euler)
|
|
{
|
|
Quaternion quaternion;
|
|
Quaternion.INTERNAL_CALL_Internal_FromEulerRad(ref euler, out quaternion);
|
|
return quaternion;
|
|
}
|
|
|
|
// Token: 0x06000971 RID: 2417
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_CALL_Internal_FromEulerRad(ref Vector3 euler, out Quaternion value);
|
|
|
|
// Token: 0x06000972 RID: 2418 RVA: 0x0000C3F0 File Offset: 0x0000A5F0
|
|
private static void Internal_ToAxisAngleRad(Quaternion q, out Vector3 axis, out float angle)
|
|
{
|
|
Quaternion.INTERNAL_CALL_Internal_ToAxisAngleRad(ref q, out axis, out angle);
|
|
}
|
|
|
|
// Token: 0x06000973 RID: 2419
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_CALL_Internal_ToAxisAngleRad(ref Quaternion q, out Vector3 axis, out float angle);
|
|
|
|
// Token: 0x06000974 RID: 2420 RVA: 0x0000C3FC File Offset: 0x0000A5FC
|
|
[Obsolete("Use Quaternion.Euler instead. This function was deprecated because it uses radians instead of degrees")]
|
|
public static Quaternion EulerRotation(float x, float y, float z)
|
|
{
|
|
return Quaternion.Internal_FromEulerRad(new Vector3(x, y, z));
|
|
}
|
|
|
|
// Token: 0x06000975 RID: 2421 RVA: 0x0000C420 File Offset: 0x0000A620
|
|
[Obsolete("Use Quaternion.Euler instead. This function was deprecated because it uses radians instead of degrees")]
|
|
public static Quaternion EulerRotation(Vector3 euler)
|
|
{
|
|
return Quaternion.Internal_FromEulerRad(euler);
|
|
}
|
|
|
|
// Token: 0x06000976 RID: 2422 RVA: 0x0000C43C File Offset: 0x0000A63C
|
|
[Obsolete("Use Quaternion.Euler instead. This function was deprecated because it uses radians instead of degrees")]
|
|
public void SetEulerRotation(float x, float y, float z)
|
|
{
|
|
this = Quaternion.Internal_FromEulerRad(new Vector3(x, y, z));
|
|
}
|
|
|
|
// Token: 0x06000977 RID: 2423 RVA: 0x0000C454 File Offset: 0x0000A654
|
|
[Obsolete("Use Quaternion.Euler instead. This function was deprecated because it uses radians instead of degrees")]
|
|
public void SetEulerRotation(Vector3 euler)
|
|
{
|
|
this = Quaternion.Internal_FromEulerRad(euler);
|
|
}
|
|
|
|
// Token: 0x06000978 RID: 2424 RVA: 0x0000C464 File Offset: 0x0000A664
|
|
[Obsolete("Use Quaternion.eulerAngles instead. This function was deprecated because it uses radians instead of degrees")]
|
|
public Vector3 ToEuler()
|
|
{
|
|
return Quaternion.Internal_ToEulerRad(this);
|
|
}
|
|
|
|
// Token: 0x06000979 RID: 2425 RVA: 0x0000C484 File Offset: 0x0000A684
|
|
[Obsolete("Use Quaternion.Euler instead. This function was deprecated because it uses radians instead of degrees")]
|
|
public static Quaternion EulerAngles(float x, float y, float z)
|
|
{
|
|
return Quaternion.Internal_FromEulerRad(new Vector3(x, y, z));
|
|
}
|
|
|
|
// Token: 0x0600097A RID: 2426 RVA: 0x0000C4A8 File Offset: 0x0000A6A8
|
|
[Obsolete("Use Quaternion.Euler instead. This function was deprecated because it uses radians instead of degrees")]
|
|
public static Quaternion EulerAngles(Vector3 euler)
|
|
{
|
|
return Quaternion.Internal_FromEulerRad(euler);
|
|
}
|
|
|
|
// Token: 0x0600097B RID: 2427 RVA: 0x0000C4C4 File Offset: 0x0000A6C4
|
|
[Obsolete("Use Quaternion.ToAngleAxis instead. This function was deprecated because it uses radians instead of degrees")]
|
|
public void ToAxisAngle(out Vector3 axis, out float angle)
|
|
{
|
|
Quaternion.Internal_ToAxisAngleRad(this, out axis, out angle);
|
|
}
|
|
|
|
// Token: 0x0600097C RID: 2428 RVA: 0x0000C4D4 File Offset: 0x0000A6D4
|
|
[Obsolete("Use Quaternion.Euler instead. This function was deprecated because it uses radians instead of degrees")]
|
|
public void SetEulerAngles(float x, float y, float z)
|
|
{
|
|
this.SetEulerRotation(new Vector3(x, y, z));
|
|
}
|
|
|
|
// Token: 0x0600097D RID: 2429 RVA: 0x0000C4E8 File Offset: 0x0000A6E8
|
|
[Obsolete("Use Quaternion.Euler instead. This function was deprecated because it uses radians instead of degrees")]
|
|
public void SetEulerAngles(Vector3 euler)
|
|
{
|
|
this = Quaternion.EulerRotation(euler);
|
|
}
|
|
|
|
// Token: 0x0600097E RID: 2430 RVA: 0x0000C4F8 File Offset: 0x0000A6F8
|
|
[Obsolete("Use Quaternion.eulerAngles instead. This function was deprecated because it uses radians instead of degrees")]
|
|
public static Vector3 ToEulerAngles(Quaternion rotation)
|
|
{
|
|
return Quaternion.Internal_ToEulerRad(rotation);
|
|
}
|
|
|
|
// Token: 0x0600097F RID: 2431 RVA: 0x0000C514 File Offset: 0x0000A714
|
|
[Obsolete("Use Quaternion.eulerAngles instead. This function was deprecated because it uses radians instead of degrees")]
|
|
public Vector3 ToEulerAngles()
|
|
{
|
|
return Quaternion.Internal_ToEulerRad(this);
|
|
}
|
|
|
|
// Token: 0x06000980 RID: 2432 RVA: 0x0000C534 File Offset: 0x0000A734
|
|
[Obsolete("Use Quaternion.AngleAxis instead. This function was deprecated because it uses radians instead of degrees")]
|
|
public static Quaternion AxisAngle(Vector3 axis, float angle)
|
|
{
|
|
Quaternion quaternion;
|
|
Quaternion.INTERNAL_CALL_AxisAngle(ref axis, angle, out quaternion);
|
|
return quaternion;
|
|
}
|
|
|
|
// Token: 0x06000981 RID: 2433
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_CALL_AxisAngle(ref Vector3 axis, float angle, out Quaternion value);
|
|
|
|
// Token: 0x06000982 RID: 2434 RVA: 0x0000C554 File Offset: 0x0000A754
|
|
[Obsolete("Use Quaternion.AngleAxis instead. This function was deprecated because it uses radians instead of degrees")]
|
|
public void SetAxisAngle(Vector3 axis, float angle)
|
|
{
|
|
this = Quaternion.AxisAngle(axis, angle);
|
|
}
|
|
|
|
// Token: 0x17000242 RID: 578
|
|
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 Quaternion 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 Quaternion index!");
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000985 RID: 2437 RVA: 0x0000C630 File Offset: 0x0000A830
|
|
public void Set(float newX, float newY, float newZ, float newW)
|
|
{
|
|
this.x = newX;
|
|
this.y = newY;
|
|
this.z = newZ;
|
|
this.w = newW;
|
|
}
|
|
|
|
// Token: 0x17000243 RID: 579
|
|
// (get) Token: 0x06000986 RID: 2438 RVA: 0x0000C650 File Offset: 0x0000A850
|
|
public static Quaternion identity
|
|
{
|
|
get
|
|
{
|
|
return Quaternion.identityQuaternion;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000987 RID: 2439 RVA: 0x0000C66C File Offset: 0x0000A86C
|
|
public static Quaternion operator *(Quaternion lhs, Quaternion rhs)
|
|
{
|
|
return new Quaternion(lhs.w * rhs.x + lhs.x * rhs.w + lhs.y * rhs.z - lhs.z * rhs.y, lhs.w * rhs.y + lhs.y * rhs.w + lhs.z * rhs.x - lhs.x * rhs.z, lhs.w * rhs.z + lhs.z * rhs.w + lhs.x * rhs.y - lhs.y * rhs.x, lhs.w * rhs.w - lhs.x * rhs.x - lhs.y * rhs.y - lhs.z * rhs.z);
|
|
}
|
|
|
|
// Token: 0x06000988 RID: 2440 RVA: 0x0000C784 File Offset: 0x0000A984
|
|
public static Vector3 operator *(Quaternion rotation, Vector3 point)
|
|
{
|
|
float num = rotation.x * 2f;
|
|
float num2 = rotation.y * 2f;
|
|
float num3 = rotation.z * 2f;
|
|
float num4 = rotation.x * num;
|
|
float num5 = rotation.y * num2;
|
|
float num6 = rotation.z * num3;
|
|
float num7 = rotation.x * num2;
|
|
float num8 = rotation.x * num3;
|
|
float num9 = rotation.y * num3;
|
|
float num10 = rotation.w * num;
|
|
float num11 = rotation.w * num2;
|
|
float num12 = rotation.w * num3;
|
|
Vector3 vector;
|
|
vector.x = (1f - (num5 + num6)) * point.x + (num7 - num12) * point.y + (num8 + num11) * point.z;
|
|
vector.y = (num7 + num12) * point.x + (1f - (num4 + num6)) * point.y + (num9 - num10) * point.z;
|
|
vector.z = (num8 - num11) * point.x + (num9 + num10) * point.y + (1f - (num4 + num5)) * point.z;
|
|
return vector;
|
|
}
|
|
|
|
// Token: 0x06000989 RID: 2441 RVA: 0x0000C8CC File Offset: 0x0000AACC
|
|
public static bool operator ==(Quaternion lhs, Quaternion rhs)
|
|
{
|
|
return Quaternion.Dot(lhs, rhs) > 0.999999f;
|
|
}
|
|
|
|
// Token: 0x0600098A RID: 2442 RVA: 0x0000C8F0 File Offset: 0x0000AAF0
|
|
public static bool operator !=(Quaternion lhs, Quaternion rhs)
|
|
{
|
|
return !(lhs == rhs);
|
|
}
|
|
|
|
// Token: 0x0600098B RID: 2443 RVA: 0x0000C910 File Offset: 0x0000AB10
|
|
public static float Dot(Quaternion a, Quaternion b)
|
|
{
|
|
return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
|
|
}
|
|
|
|
// Token: 0x0600098C RID: 2444 RVA: 0x0000C964 File Offset: 0x0000AB64
|
|
[ExcludeFromDocs]
|
|
public void SetLookRotation(Vector3 view)
|
|
{
|
|
Vector3 up = Vector3.up;
|
|
this.SetLookRotation(view, up);
|
|
}
|
|
|
|
// Token: 0x0600098D RID: 2445 RVA: 0x0000C980 File Offset: 0x0000AB80
|
|
public void SetLookRotation(Vector3 view, [DefaultValue("Vector3.up")] Vector3 up)
|
|
{
|
|
this = Quaternion.LookRotation(view, up);
|
|
}
|
|
|
|
// Token: 0x0600098E RID: 2446 RVA: 0x0000C990 File Offset: 0x0000AB90
|
|
public static float Angle(Quaternion a, Quaternion b)
|
|
{
|
|
float num = Quaternion.Dot(a, b);
|
|
return Mathf.Acos(Mathf.Min(Mathf.Abs(num), 1f)) * 2f * 57.29578f;
|
|
}
|
|
|
|
// Token: 0x0600098F RID: 2447 RVA: 0x0000C9D0 File Offset: 0x0000ABD0
|
|
private static Vector3 Internal_MakePositive(Vector3 euler)
|
|
{
|
|
float num = -0.005729578f;
|
|
float num2 = 360f + num;
|
|
if (euler.x < num)
|
|
{
|
|
euler.x += 360f;
|
|
}
|
|
else if (euler.x > num2)
|
|
{
|
|
euler.x -= 360f;
|
|
}
|
|
if (euler.y < num)
|
|
{
|
|
euler.y += 360f;
|
|
}
|
|
else if (euler.y > num2)
|
|
{
|
|
euler.y -= 360f;
|
|
}
|
|
if (euler.z < num)
|
|
{
|
|
euler.z += 360f;
|
|
}
|
|
else if (euler.z > num2)
|
|
{
|
|
euler.z -= 360f;
|
|
}
|
|
return euler;
|
|
}
|
|
|
|
// Token: 0x06000990 RID: 2448 RVA: 0x0000CAC4 File Offset: 0x0000ACC4
|
|
public override int GetHashCode()
|
|
{
|
|
return this.x.GetHashCode() ^ (this.y.GetHashCode() << 2) ^ (this.z.GetHashCode() >> 2) ^ (this.w.GetHashCode() >> 1);
|
|
}
|
|
|
|
// Token: 0x06000991 RID: 2449 RVA: 0x0000CB28 File Offset: 0x0000AD28
|
|
public override bool Equals(object other)
|
|
{
|
|
bool flag;
|
|
if (!(other is Quaternion))
|
|
{
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
Quaternion quaternion = (Quaternion)other;
|
|
flag = this.x.Equals(quaternion.x) && this.y.Equals(quaternion.y) && this.z.Equals(quaternion.z) && this.w.Equals(quaternion.w);
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x06000992 RID: 2450 RVA: 0x0000CBB0 File Offset: 0x0000ADB0
|
|
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: 0x06000993 RID: 2451 RVA: 0x0000CC10 File Offset: 0x0000AE10
|
|
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: 0x040000DF RID: 223
|
|
public float x;
|
|
|
|
// Token: 0x040000E0 RID: 224
|
|
public float y;
|
|
|
|
// Token: 0x040000E1 RID: 225
|
|
public float z;
|
|
|
|
// Token: 0x040000E2 RID: 226
|
|
public float w;
|
|
|
|
// Token: 0x040000E3 RID: 227
|
|
private static readonly Quaternion identityQuaternion = new Quaternion(0f, 0f, 0f, 1f);
|
|
|
|
// Token: 0x040000E4 RID: 228
|
|
public const float kEpsilon = 1E-06f;
|
|
}
|
|
}
|