niko
652 lines
19 KiB
C#
652 lines
19 KiB
C#
using System;
|
|
using System.Runtime.CompilerServices;
|
|
using UnityEngine.Internal;
|
|
using UnityEngine.Scripting;
|
|
|
|
namespace UnityEngine
|
|
{
|
|
// Token: 0x02000083 RID: 131
|
|
[UsedByNativeCode]
|
|
public struct Vector3
|
|
{
|
|
// Token: 0x06000910 RID: 2320 RVA: 0x0000B1BC File Offset: 0x000093BC
|
|
public Vector3(float x, float y, float z)
|
|
{
|
|
this.x = x;
|
|
this.y = y;
|
|
this.z = z;
|
|
}
|
|
|
|
// Token: 0x06000911 RID: 2321 RVA: 0x0000B1D4 File Offset: 0x000093D4
|
|
public Vector3(float x, float y)
|
|
{
|
|
this.x = x;
|
|
this.y = y;
|
|
this.z = 0f;
|
|
}
|
|
|
|
// Token: 0x06000912 RID: 2322 RVA: 0x0000B1F0 File Offset: 0x000093F0
|
|
[ThreadAndSerializationSafe]
|
|
public static Vector3 Slerp(Vector3 a, Vector3 b, float t)
|
|
{
|
|
Vector3 vector;
|
|
Vector3.INTERNAL_CALL_Slerp(ref a, ref b, t, out vector);
|
|
return vector;
|
|
}
|
|
|
|
// Token: 0x06000913 RID: 2323
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_CALL_Slerp(ref Vector3 a, ref Vector3 b, float t, out Vector3 value);
|
|
|
|
// Token: 0x06000914 RID: 2324 RVA: 0x0000B214 File Offset: 0x00009414
|
|
public static Vector3 SlerpUnclamped(Vector3 a, Vector3 b, float t)
|
|
{
|
|
Vector3 vector;
|
|
Vector3.INTERNAL_CALL_SlerpUnclamped(ref a, ref b, t, out vector);
|
|
return vector;
|
|
}
|
|
|
|
// Token: 0x06000915 RID: 2325
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_CALL_SlerpUnclamped(ref Vector3 a, ref Vector3 b, float t, out Vector3 value);
|
|
|
|
// Token: 0x06000916 RID: 2326 RVA: 0x0000B238 File Offset: 0x00009438
|
|
private static void Internal_OrthoNormalize2(ref Vector3 a, ref Vector3 b)
|
|
{
|
|
Vector3.INTERNAL_CALL_Internal_OrthoNormalize2(ref a, ref b);
|
|
}
|
|
|
|
// Token: 0x06000917 RID: 2327
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_CALL_Internal_OrthoNormalize2(ref Vector3 a, ref Vector3 b);
|
|
|
|
// Token: 0x06000918 RID: 2328 RVA: 0x0000B244 File Offset: 0x00009444
|
|
private static void Internal_OrthoNormalize3(ref Vector3 a, ref Vector3 b, ref Vector3 c)
|
|
{
|
|
Vector3.INTERNAL_CALL_Internal_OrthoNormalize3(ref a, ref b, ref c);
|
|
}
|
|
|
|
// Token: 0x06000919 RID: 2329
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_CALL_Internal_OrthoNormalize3(ref Vector3 a, ref Vector3 b, ref Vector3 c);
|
|
|
|
// Token: 0x0600091A RID: 2330 RVA: 0x0000B250 File Offset: 0x00009450
|
|
public static void OrthoNormalize(ref Vector3 normal, ref Vector3 tangent)
|
|
{
|
|
Vector3.Internal_OrthoNormalize2(ref normal, ref tangent);
|
|
}
|
|
|
|
// Token: 0x0600091B RID: 2331 RVA: 0x0000B25C File Offset: 0x0000945C
|
|
public static void OrthoNormalize(ref Vector3 normal, ref Vector3 tangent, ref Vector3 binormal)
|
|
{
|
|
Vector3.Internal_OrthoNormalize3(ref normal, ref tangent, ref binormal);
|
|
}
|
|
|
|
// Token: 0x0600091C RID: 2332 RVA: 0x0000B268 File Offset: 0x00009468
|
|
public static Vector3 RotateTowards(Vector3 current, Vector3 target, float maxRadiansDelta, float maxMagnitudeDelta)
|
|
{
|
|
Vector3 vector;
|
|
Vector3.INTERNAL_CALL_RotateTowards(ref current, ref target, maxRadiansDelta, maxMagnitudeDelta, out vector);
|
|
return vector;
|
|
}
|
|
|
|
// Token: 0x0600091D RID: 2333
|
|
[GeneratedByOldBindingsGenerator]
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern void INTERNAL_CALL_RotateTowards(ref Vector3 current, ref Vector3 target, float maxRadiansDelta, float maxMagnitudeDelta, out Vector3 value);
|
|
|
|
// Token: 0x0600091E RID: 2334 RVA: 0x0000B28C File Offset: 0x0000948C
|
|
[Obsolete("Use Vector3.ProjectOnPlane instead.")]
|
|
public static Vector3 Exclude(Vector3 excludeThis, Vector3 fromThat)
|
|
{
|
|
return fromThat - Vector3.Project(fromThat, excludeThis);
|
|
}
|
|
|
|
// Token: 0x0600091F RID: 2335 RVA: 0x0000B2B0 File Offset: 0x000094B0
|
|
public static Vector3 Lerp(Vector3 a, Vector3 b, float t)
|
|
{
|
|
t = Mathf.Clamp01(t);
|
|
return new Vector3(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t);
|
|
}
|
|
|
|
// Token: 0x06000920 RID: 2336 RVA: 0x0000B320 File Offset: 0x00009520
|
|
public static Vector3 LerpUnclamped(Vector3 a, Vector3 b, float t)
|
|
{
|
|
return new Vector3(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t);
|
|
}
|
|
|
|
// Token: 0x06000921 RID: 2337 RVA: 0x0000B388 File Offset: 0x00009588
|
|
public static Vector3 MoveTowards(Vector3 current, Vector3 target, float maxDistanceDelta)
|
|
{
|
|
Vector3 vector = target - current;
|
|
float magnitude = vector.magnitude;
|
|
Vector3 vector2;
|
|
if (magnitude <= maxDistanceDelta || magnitude < 1E-45f)
|
|
{
|
|
vector2 = target;
|
|
}
|
|
else
|
|
{
|
|
vector2 = current + vector / magnitude * maxDistanceDelta;
|
|
}
|
|
return vector2;
|
|
}
|
|
|
|
// Token: 0x06000922 RID: 2338 RVA: 0x0000B3DC File Offset: 0x000095DC
|
|
[ExcludeFromDocs]
|
|
public static Vector3 SmoothDamp(Vector3 current, Vector3 target, ref Vector3 currentVelocity, float smoothTime, float maxSpeed)
|
|
{
|
|
float deltaTime = Time.deltaTime;
|
|
return Vector3.SmoothDamp(current, target, ref currentVelocity, smoothTime, maxSpeed, deltaTime);
|
|
}
|
|
|
|
// Token: 0x06000923 RID: 2339 RVA: 0x0000B404 File Offset: 0x00009604
|
|
[ExcludeFromDocs]
|
|
public static Vector3 SmoothDamp(Vector3 current, Vector3 target, ref Vector3 currentVelocity, float smoothTime)
|
|
{
|
|
float deltaTime = Time.deltaTime;
|
|
float positiveInfinity = float.PositiveInfinity;
|
|
return Vector3.SmoothDamp(current, target, ref currentVelocity, smoothTime, positiveInfinity, deltaTime);
|
|
}
|
|
|
|
// Token: 0x06000924 RID: 2340 RVA: 0x0000B430 File Offset: 0x00009630
|
|
public static Vector3 SmoothDamp(Vector3 current, Vector3 target, ref Vector3 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);
|
|
Vector3 vector = current - target;
|
|
Vector3 vector2 = target;
|
|
float num4 = maxSpeed * smoothTime;
|
|
vector = Vector3.ClampMagnitude(vector, num4);
|
|
target = current - vector;
|
|
Vector3 vector3 = (currentVelocity + num * vector) * deltaTime;
|
|
currentVelocity = (currentVelocity - num * vector3) * num3;
|
|
Vector3 vector4 = target + (vector + vector3) * num3;
|
|
if (Vector3.Dot(vector2 - current, vector4 - vector2) > 0f)
|
|
{
|
|
vector4 = vector2;
|
|
currentVelocity = (vector4 - vector2) / deltaTime;
|
|
}
|
|
return vector4;
|
|
}
|
|
|
|
// Token: 0x17000232 RID: 562
|
|
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;
|
|
default:
|
|
throw new IndexOutOfRangeException("Invalid Vector3 index!");
|
|
}
|
|
return num;
|
|
}
|
|
set
|
|
{
|
|
switch (index)
|
|
{
|
|
case 0:
|
|
this.x = value;
|
|
break;
|
|
case 1:
|
|
this.y = value;
|
|
break;
|
|
case 2:
|
|
this.z = value;
|
|
break;
|
|
default:
|
|
throw new IndexOutOfRangeException("Invalid Vector3 index!");
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000927 RID: 2343 RVA: 0x0000B5E4 File Offset: 0x000097E4
|
|
public void Set(float newX, float newY, float newZ)
|
|
{
|
|
this.x = newX;
|
|
this.y = newY;
|
|
this.z = newZ;
|
|
}
|
|
|
|
// Token: 0x06000928 RID: 2344 RVA: 0x0000B5FC File Offset: 0x000097FC
|
|
public static Vector3 Scale(Vector3 a, Vector3 b)
|
|
{
|
|
return new Vector3(a.x * b.x, a.y * b.y, a.z * b.z);
|
|
}
|
|
|
|
// Token: 0x06000929 RID: 2345 RVA: 0x0000B644 File Offset: 0x00009844
|
|
public void Scale(Vector3 scale)
|
|
{
|
|
this.x *= scale.x;
|
|
this.y *= scale.y;
|
|
this.z *= scale.z;
|
|
}
|
|
|
|
// Token: 0x0600092A RID: 2346 RVA: 0x0000B684 File Offset: 0x00009884
|
|
public static Vector3 Cross(Vector3 lhs, Vector3 rhs)
|
|
{
|
|
return new Vector3(lhs.y * rhs.z - lhs.z * rhs.y, lhs.z * rhs.x - lhs.x * rhs.z, lhs.x * rhs.y - lhs.y * rhs.x);
|
|
}
|
|
|
|
// Token: 0x0600092B RID: 2347 RVA: 0x0000B6FC File Offset: 0x000098FC
|
|
public override int GetHashCode()
|
|
{
|
|
return this.x.GetHashCode() ^ (this.y.GetHashCode() << 2) ^ (this.z.GetHashCode() >> 2);
|
|
}
|
|
|
|
// Token: 0x0600092C RID: 2348 RVA: 0x0000B74C File Offset: 0x0000994C
|
|
public override bool Equals(object other)
|
|
{
|
|
bool flag;
|
|
if (!(other is Vector3))
|
|
{
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
Vector3 vector = (Vector3)other;
|
|
flag = this.x.Equals(vector.x) && this.y.Equals(vector.y) && this.z.Equals(vector.z);
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x0600092D RID: 2349 RVA: 0x0000B7C0 File Offset: 0x000099C0
|
|
public static Vector3 Reflect(Vector3 inDirection, Vector3 inNormal)
|
|
{
|
|
return -2f * Vector3.Dot(inNormal, inDirection) * inNormal + inDirection;
|
|
}
|
|
|
|
// Token: 0x0600092E RID: 2350 RVA: 0x0000B7F0 File Offset: 0x000099F0
|
|
public static Vector3 Normalize(Vector3 value)
|
|
{
|
|
float num = Vector3.Magnitude(value);
|
|
Vector3 vector;
|
|
if (num > 1E-05f)
|
|
{
|
|
vector = value / num;
|
|
}
|
|
else
|
|
{
|
|
vector = Vector3.zero;
|
|
}
|
|
return vector;
|
|
}
|
|
|
|
// Token: 0x0600092F RID: 2351 RVA: 0x0000B82C File Offset: 0x00009A2C
|
|
public void Normalize()
|
|
{
|
|
float num = Vector3.Magnitude(this);
|
|
if (num > 1E-05f)
|
|
{
|
|
this /= num;
|
|
}
|
|
else
|
|
{
|
|
this = Vector3.zero;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000233 RID: 563
|
|
// (get) Token: 0x06000930 RID: 2352 RVA: 0x0000B874 File Offset: 0x00009A74
|
|
public Vector3 normalized
|
|
{
|
|
get
|
|
{
|
|
return Vector3.Normalize(this);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000931 RID: 2353 RVA: 0x0000B894 File Offset: 0x00009A94
|
|
public static float Dot(Vector3 lhs, Vector3 rhs)
|
|
{
|
|
return lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z;
|
|
}
|
|
|
|
// Token: 0x06000932 RID: 2354 RVA: 0x0000B8D8 File Offset: 0x00009AD8
|
|
public static Vector3 Project(Vector3 vector, Vector3 onNormal)
|
|
{
|
|
float num = Vector3.Dot(onNormal, onNormal);
|
|
Vector3 vector2;
|
|
if (num < Mathf.Epsilon)
|
|
{
|
|
vector2 = Vector3.zero;
|
|
}
|
|
else
|
|
{
|
|
vector2 = onNormal * Vector3.Dot(vector, onNormal) / num;
|
|
}
|
|
return vector2;
|
|
}
|
|
|
|
// Token: 0x06000933 RID: 2355 RVA: 0x0000B920 File Offset: 0x00009B20
|
|
public static Vector3 ProjectOnPlane(Vector3 vector, Vector3 planeNormal)
|
|
{
|
|
return vector - Vector3.Project(vector, planeNormal);
|
|
}
|
|
|
|
// Token: 0x06000934 RID: 2356 RVA: 0x0000B944 File Offset: 0x00009B44
|
|
public static float Angle(Vector3 from, Vector3 to)
|
|
{
|
|
return Mathf.Acos(Mathf.Clamp(Vector3.Dot(from.normalized, to.normalized), -1f, 1f)) * 57.29578f;
|
|
}
|
|
|
|
// Token: 0x06000935 RID: 2357 RVA: 0x0000B988 File Offset: 0x00009B88
|
|
public static float SignedAngle(Vector3 from, Vector3 to, Vector3 axis)
|
|
{
|
|
Vector3 normalized = from.normalized;
|
|
Vector3 normalized2 = to.normalized;
|
|
float num = Mathf.Acos(Mathf.Clamp(Vector3.Dot(normalized, normalized2), -1f, 1f)) * 57.29578f;
|
|
float num2 = Mathf.Sign(Vector3.Dot(axis, Vector3.Cross(normalized, normalized2)));
|
|
return num * num2;
|
|
}
|
|
|
|
// Token: 0x06000936 RID: 2358 RVA: 0x0000B9E8 File Offset: 0x00009BE8
|
|
public static float Distance(Vector3 a, Vector3 b)
|
|
{
|
|
Vector3 vector = new Vector3(a.x - b.x, a.y - b.y, a.z - b.z);
|
|
return Mathf.Sqrt(vector.x * vector.x + vector.y * vector.y + vector.z * vector.z);
|
|
}
|
|
|
|
// Token: 0x06000937 RID: 2359 RVA: 0x0000BA68 File Offset: 0x00009C68
|
|
public static Vector3 ClampMagnitude(Vector3 vector, float maxLength)
|
|
{
|
|
Vector3 vector2;
|
|
if (vector.sqrMagnitude > maxLength * maxLength)
|
|
{
|
|
vector2 = vector.normalized * maxLength;
|
|
}
|
|
else
|
|
{
|
|
vector2 = vector;
|
|
}
|
|
return vector2;
|
|
}
|
|
|
|
// Token: 0x06000938 RID: 2360 RVA: 0x0000BAA0 File Offset: 0x00009CA0
|
|
public static float Magnitude(Vector3 vector)
|
|
{
|
|
return Mathf.Sqrt(vector.x * vector.x + vector.y * vector.y + vector.z * vector.z);
|
|
}
|
|
|
|
// Token: 0x17000234 RID: 564
|
|
// (get) Token: 0x06000939 RID: 2361 RVA: 0x0000BAEC File Offset: 0x00009CEC
|
|
public float magnitude
|
|
{
|
|
get
|
|
{
|
|
return Mathf.Sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600093A RID: 2362 RVA: 0x0000BB30 File Offset: 0x00009D30
|
|
public static float SqrMagnitude(Vector3 vector)
|
|
{
|
|
return vector.x * vector.x + vector.y * vector.y + vector.z * vector.z;
|
|
}
|
|
|
|
// Token: 0x17000235 RID: 565
|
|
// (get) Token: 0x0600093B RID: 2363 RVA: 0x0000BB74 File Offset: 0x00009D74
|
|
public float sqrMagnitude
|
|
{
|
|
get
|
|
{
|
|
return this.x * this.x + this.y * this.y + this.z * this.z;
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600093C RID: 2364 RVA: 0x0000BBB4 File Offset: 0x00009DB4
|
|
public static Vector3 Min(Vector3 lhs, Vector3 rhs)
|
|
{
|
|
return new Vector3(Mathf.Min(lhs.x, rhs.x), Mathf.Min(lhs.y, rhs.y), Mathf.Min(lhs.z, rhs.z));
|
|
}
|
|
|
|
// Token: 0x0600093D RID: 2365 RVA: 0x0000BC08 File Offset: 0x00009E08
|
|
public static Vector3 Max(Vector3 lhs, Vector3 rhs)
|
|
{
|
|
return new Vector3(Mathf.Max(lhs.x, rhs.x), Mathf.Max(lhs.y, rhs.y), Mathf.Max(lhs.z, rhs.z));
|
|
}
|
|
|
|
// Token: 0x17000236 RID: 566
|
|
// (get) Token: 0x0600093E RID: 2366 RVA: 0x0000BC5C File Offset: 0x00009E5C
|
|
public static Vector3 zero
|
|
{
|
|
get
|
|
{
|
|
return Vector3.zeroVector;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000237 RID: 567
|
|
// (get) Token: 0x0600093F RID: 2367 RVA: 0x0000BC78 File Offset: 0x00009E78
|
|
public static Vector3 one
|
|
{
|
|
get
|
|
{
|
|
return Vector3.oneVector;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000238 RID: 568
|
|
// (get) Token: 0x06000940 RID: 2368 RVA: 0x0000BC94 File Offset: 0x00009E94
|
|
public static Vector3 forward
|
|
{
|
|
get
|
|
{
|
|
return Vector3.forwardVector;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000239 RID: 569
|
|
// (get) Token: 0x06000941 RID: 2369 RVA: 0x0000BCB0 File Offset: 0x00009EB0
|
|
public static Vector3 back
|
|
{
|
|
get
|
|
{
|
|
return Vector3.backVector;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700023A RID: 570
|
|
// (get) Token: 0x06000942 RID: 2370 RVA: 0x0000BCCC File Offset: 0x00009ECC
|
|
public static Vector3 up
|
|
{
|
|
get
|
|
{
|
|
return Vector3.upVector;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700023B RID: 571
|
|
// (get) Token: 0x06000943 RID: 2371 RVA: 0x0000BCE8 File Offset: 0x00009EE8
|
|
public static Vector3 down
|
|
{
|
|
get
|
|
{
|
|
return Vector3.downVector;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700023C RID: 572
|
|
// (get) Token: 0x06000944 RID: 2372 RVA: 0x0000BD04 File Offset: 0x00009F04
|
|
public static Vector3 left
|
|
{
|
|
get
|
|
{
|
|
return Vector3.leftVector;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700023D RID: 573
|
|
// (get) Token: 0x06000945 RID: 2373 RVA: 0x0000BD20 File Offset: 0x00009F20
|
|
public static Vector3 right
|
|
{
|
|
get
|
|
{
|
|
return Vector3.rightVector;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700023E RID: 574
|
|
// (get) Token: 0x06000946 RID: 2374 RVA: 0x0000BD3C File Offset: 0x00009F3C
|
|
public static Vector3 positiveInfinity
|
|
{
|
|
get
|
|
{
|
|
return Vector3.positiveInfinityVector;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700023F RID: 575
|
|
// (get) Token: 0x06000947 RID: 2375 RVA: 0x0000BD58 File Offset: 0x00009F58
|
|
public static Vector3 negativeInfinity
|
|
{
|
|
get
|
|
{
|
|
return Vector3.negativeInfinityVector;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000948 RID: 2376 RVA: 0x0000BD74 File Offset: 0x00009F74
|
|
public static Vector3 operator +(Vector3 a, Vector3 b)
|
|
{
|
|
return new Vector3(a.x + b.x, a.y + b.y, a.z + b.z);
|
|
}
|
|
|
|
// Token: 0x06000949 RID: 2377 RVA: 0x0000BDBC File Offset: 0x00009FBC
|
|
public static Vector3 operator -(Vector3 a, Vector3 b)
|
|
{
|
|
return new Vector3(a.x - b.x, a.y - b.y, a.z - b.z);
|
|
}
|
|
|
|
// Token: 0x0600094A RID: 2378 RVA: 0x0000BE04 File Offset: 0x0000A004
|
|
public static Vector3 operator -(Vector3 a)
|
|
{
|
|
return new Vector3(-a.x, -a.y, -a.z);
|
|
}
|
|
|
|
// Token: 0x0600094B RID: 2379 RVA: 0x0000BE38 File Offset: 0x0000A038
|
|
public static Vector3 operator *(Vector3 a, float d)
|
|
{
|
|
return new Vector3(a.x * d, a.y * d, a.z * d);
|
|
}
|
|
|
|
// Token: 0x0600094C RID: 2380 RVA: 0x0000BE70 File Offset: 0x0000A070
|
|
public static Vector3 operator *(float d, Vector3 a)
|
|
{
|
|
return new Vector3(a.x * d, a.y * d, a.z * d);
|
|
}
|
|
|
|
// Token: 0x0600094D RID: 2381 RVA: 0x0000BEA8 File Offset: 0x0000A0A8
|
|
public static Vector3 operator /(Vector3 a, float d)
|
|
{
|
|
return new Vector3(a.x / d, a.y / d, a.z / d);
|
|
}
|
|
|
|
// Token: 0x0600094E RID: 2382 RVA: 0x0000BEE0 File Offset: 0x0000A0E0
|
|
public static bool operator ==(Vector3 lhs, Vector3 rhs)
|
|
{
|
|
return Vector3.SqrMagnitude(lhs - rhs) < 9.9999994E-11f;
|
|
}
|
|
|
|
// Token: 0x0600094F RID: 2383 RVA: 0x0000BF08 File Offset: 0x0000A108
|
|
public static bool operator !=(Vector3 lhs, Vector3 rhs)
|
|
{
|
|
return !(lhs == rhs);
|
|
}
|
|
|
|
// Token: 0x06000950 RID: 2384 RVA: 0x0000BF28 File Offset: 0x0000A128
|
|
public override string ToString()
|
|
{
|
|
return UnityString.Format("({0:F1}, {1:F1}, {2:F1})", new object[] { this.x, this.y, this.z });
|
|
}
|
|
|
|
// Token: 0x06000951 RID: 2385 RVA: 0x0000BF78 File Offset: 0x0000A178
|
|
public string ToString(string format)
|
|
{
|
|
return UnityString.Format("({0}, {1}, {2})", new object[]
|
|
{
|
|
this.x.ToString(format),
|
|
this.y.ToString(format),
|
|
this.z.ToString(format)
|
|
});
|
|
}
|
|
|
|
// Token: 0x17000240 RID: 576
|
|
// (get) Token: 0x06000952 RID: 2386 RVA: 0x0000BFCC File Offset: 0x0000A1CC
|
|
[Obsolete("Use Vector3.forward instead.")]
|
|
public static Vector3 fwd
|
|
{
|
|
get
|
|
{
|
|
return new Vector3(0f, 0f, 1f);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000953 RID: 2387 RVA: 0x0000BFF8 File Offset: 0x0000A1F8
|
|
[Obsolete("Use Vector3.Angle instead. AngleBetween uses radians instead of degrees and was deprecated for this reason")]
|
|
public static float AngleBetween(Vector3 from, Vector3 to)
|
|
{
|
|
return Mathf.Acos(Mathf.Clamp(Vector3.Dot(from.normalized, to.normalized), -1f, 1f));
|
|
}
|
|
|
|
// Token: 0x040000D1 RID: 209
|
|
public const float kEpsilon = 1E-05f;
|
|
|
|
// Token: 0x040000D2 RID: 210
|
|
public float x;
|
|
|
|
// Token: 0x040000D3 RID: 211
|
|
public float y;
|
|
|
|
// Token: 0x040000D4 RID: 212
|
|
public float z;
|
|
|
|
// Token: 0x040000D5 RID: 213
|
|
private static readonly Vector3 zeroVector = new Vector3(0f, 0f, 0f);
|
|
|
|
// Token: 0x040000D6 RID: 214
|
|
private static readonly Vector3 oneVector = new Vector3(1f, 1f, 1f);
|
|
|
|
// Token: 0x040000D7 RID: 215
|
|
private static readonly Vector3 upVector = new Vector3(0f, 1f, 0f);
|
|
|
|
// Token: 0x040000D8 RID: 216
|
|
private static readonly Vector3 downVector = new Vector3(0f, -1f, 0f);
|
|
|
|
// Token: 0x040000D9 RID: 217
|
|
private static readonly Vector3 leftVector = new Vector3(-1f, 0f, 0f);
|
|
|
|
// Token: 0x040000DA RID: 218
|
|
private static readonly Vector3 rightVector = new Vector3(1f, 0f, 0f);
|
|
|
|
// Token: 0x040000DB RID: 219
|
|
private static readonly Vector3 forwardVector = new Vector3(0f, 0f, 1f);
|
|
|
|
// Token: 0x040000DC RID: 220
|
|
private static readonly Vector3 backVector = new Vector3(0f, 0f, -1f);
|
|
|
|
// Token: 0x040000DD RID: 221
|
|
private static readonly Vector3 positiveInfinityVector = new Vector3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity);
|
|
|
|
// Token: 0x040000DE RID: 222
|
|
private static readonly Vector3 negativeInfinityVector = new Vector3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity);
|
|
}
|
|
}
|