You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
497 lines
16 KiB
497 lines
16 KiB
using System; |
|
using System.Globalization; |
|
using MongoDB.Bson; |
|
using MongoDB.Bson.Serialization.Attributes; |
|
|
|
namespace UnityEngine |
|
{ |
|
[Serializable] |
|
public struct Vector2: IEquatable<Vector2> |
|
{ |
|
public static readonly Vector2 zero = new Vector2(); |
|
public static readonly Vector2 one = new Vector2(1f, 1f); |
|
|
|
[BsonRepresentation(BsonType.Double, AllowTruncation = true)] |
|
public float x; |
|
[BsonRepresentation(BsonType.Double, AllowTruncation = true)] |
|
public float y; |
|
|
|
public static implicit operator Vector2(Vector3 v) |
|
{ |
|
return new Vector2(v.x, v.y); |
|
} |
|
|
|
public static implicit operator Vector3(Vector2 v) |
|
{ |
|
return new Vector3(v.x, v.y, 0.0f); |
|
} |
|
|
|
public Vector2(float x, float y) |
|
{ |
|
this.x = x; |
|
this.y = y; |
|
} |
|
|
|
public Vector2(float value) |
|
{ |
|
this.x = this.y = value; |
|
} |
|
|
|
public float this[int index] |
|
{ |
|
get |
|
{ |
|
if (index == 0) |
|
return this.x; |
|
if (index == 1) |
|
return this.y; |
|
throw new IndexOutOfRangeException("Invalid Vector2 index!"); |
|
} |
|
set |
|
{ |
|
if (index != 0) |
|
{ |
|
if (index != 1) |
|
throw new IndexOutOfRangeException("Invalid Vector2 index!"); |
|
this.y = value; |
|
} |
|
else |
|
this.x = value; |
|
} |
|
} |
|
|
|
public override string ToString() |
|
{ |
|
CultureInfo currentCulture = CultureInfo.CurrentCulture; |
|
return string.Format(currentCulture, "{0}, {1}", |
|
new object[2] |
|
{ |
|
this.x.ToString(currentCulture), |
|
this.y.ToString(currentCulture) |
|
}); |
|
} |
|
|
|
public bool Equals(Vector2 other) |
|
{ |
|
return this == other; |
|
} |
|
|
|
public override bool Equals(object obj) |
|
{ |
|
bool flag = false; |
|
if (obj is Vector2) |
|
flag = this.Equals((Vector2) obj); |
|
return flag; |
|
} |
|
|
|
public override int GetHashCode() |
|
{ |
|
return this.x.GetHashCode() + this.y.GetHashCode(); |
|
} |
|
|
|
public float Length() |
|
{ |
|
return (float) Math.Sqrt(this.x * (double) this.x + this.y * (double) this.y); |
|
} |
|
|
|
public float LengthSquared() |
|
{ |
|
return (float) (this.x * (double) this.x + this.y * (double) this.y); |
|
} |
|
|
|
public float magnitude |
|
{ |
|
get |
|
{ |
|
return this.Length(); |
|
} |
|
} |
|
|
|
public float sqrMagnitude |
|
{ |
|
get |
|
{ |
|
return this.LengthSquared(); |
|
} |
|
} |
|
|
|
public static float Distance(Vector2 value1, Vector2 value2) |
|
{ |
|
float num1 = value1.x - value2.x; |
|
float num2 = value1.y - value2.y; |
|
return (float) Math.Sqrt(num1 * (double) num1 + num2 * (double) num2); |
|
} |
|
|
|
public static void Distance(ref Vector2 value1, ref Vector2 value2, out float result) |
|
{ |
|
float num1 = value1.x - value2.x; |
|
float num2 = value1.y - value2.y; |
|
float num3 = (float) (num1 * (double) num1 + num2 * (double) num2); |
|
result = (float) Math.Sqrt(num3); |
|
} |
|
|
|
public static float DistanceSquared(Vector2 value1, Vector2 value2) |
|
{ |
|
float num1 = value1.x - value2.x; |
|
float num2 = value1.y - value2.y; |
|
return (float) (num1 * (double) num1 + num2 * (double) num2); |
|
} |
|
|
|
public static void DistanceSquared(ref Vector2 value1, ref Vector2 value2, out float result) |
|
{ |
|
float num1 = value1.x - value2.x; |
|
float num2 = value1.y - value2.y; |
|
result = (float) (num1 * (double) num1 + num2 * (double) num2); |
|
} |
|
|
|
public void Normalize() |
|
{ |
|
float num1 = (float) (this.x * (double) this.x + this.y * (double) this.y); |
|
if (num1 < 9.99999974737875E-06) |
|
return; |
|
float num2 = 1f / (float) Math.Sqrt(num1); |
|
this.x *= num2; |
|
this.y *= num2; |
|
} |
|
|
|
public static Vector2 Normalize(Vector2 value) |
|
{ |
|
float num1 = (float) (value.x * (double) value.x + value.y * (double) value.y); |
|
if (num1 < 9.99999974737875E-06) |
|
return value; |
|
float num2 = 1f / (float) Math.Sqrt(num1); |
|
Vector2 vector2; |
|
vector2.x = value.x * num2; |
|
vector2.y = value.y * num2; |
|
return vector2; |
|
} |
|
|
|
public static void Normalize(ref Vector2 value, out Vector2 result) |
|
{ |
|
float num1 = (float) (value.x * (double) value.x + value.y * (double) value.y); |
|
if (num1 < 9.99999974737875E-06) |
|
{ |
|
result = value; |
|
} |
|
else |
|
{ |
|
float num2 = 1f / (float) Math.Sqrt(num1); |
|
result.x = value.x * num2; |
|
result.y = value.y * num2; |
|
} |
|
} |
|
|
|
public Vector2 normalized |
|
{ |
|
get |
|
{ |
|
return Vector2.Normalize(this); |
|
} |
|
} |
|
|
|
public static Vector2 Reflect(Vector2 vector, Vector2 normal) |
|
{ |
|
float num = (float) (vector.x * (double) normal.x + vector.y * (double) normal.y); |
|
Vector2 vector2; |
|
vector2.x = vector.x - 2f * num * normal.x; |
|
vector2.y = vector.y - 2f * num * normal.y; |
|
return vector2; |
|
} |
|
|
|
public static void Reflect(ref Vector2 vector, ref Vector2 normal, out Vector2 result) |
|
{ |
|
float num = (float) (vector.x * (double) normal.x + vector.y * (double) normal.y); |
|
result.x = vector.x - 2f * num * normal.x; |
|
result.y = vector.y - 2f * num * normal.y; |
|
} |
|
|
|
public static Vector2 Min(Vector2 value1, Vector2 value2) |
|
{ |
|
Vector2 vector2; |
|
vector2.x = (double) value1.x < (double) value2.x? value1.x : value2.x; |
|
vector2.y = (double) value1.y < (double) value2.y? value1.y : value2.y; |
|
return vector2; |
|
} |
|
|
|
public static void Min(ref Vector2 value1, ref Vector2 value2, out Vector2 result) |
|
{ |
|
result.x = (double) value1.x < (double) value2.x? value1.x : value2.x; |
|
result.y = (double) value1.y < (double) value2.y? value1.y : value2.y; |
|
} |
|
|
|
public static Vector2 Max(Vector2 value1, Vector2 value2) |
|
{ |
|
Vector2 vector2; |
|
vector2.x = (double) value1.x > (double) value2.x? value1.x : value2.x; |
|
vector2.y = (double) value1.y > (double) value2.y? value1.y : value2.y; |
|
return vector2; |
|
} |
|
|
|
public static void Max(ref Vector2 value1, ref Vector2 value2, out Vector2 result) |
|
{ |
|
result.x = (double) value1.x > (double) value2.x? value1.x : value2.x; |
|
result.y = (double) value1.y > (double) value2.y? value1.y : value2.y; |
|
} |
|
|
|
public static Vector2 Clamp(Vector2 value1, Vector2 min, Vector2 max) |
|
{ |
|
float x = value1.x; |
|
float num1 = (double) x > (double) max.x? max.x : x; |
|
float num2 = (double) num1 < (double) min.x? min.x : num1; |
|
float y = value1.y; |
|
float num3 = (double) y > (double) max.y? max.y : y; |
|
float num4 = (double) num3 < (double) min.y? min.y : num3; |
|
Vector2 vector2; |
|
vector2.x = num2; |
|
vector2.y = num4; |
|
return vector2; |
|
} |
|
|
|
public static void Clamp(ref Vector2 value1, ref Vector2 min, ref Vector2 max, out Vector2 result) |
|
{ |
|
float x = value1.x; |
|
float num1 = (double) x > (double) max.x? max.x : x; |
|
float num2 = (double) num1 < (double) min.x? min.x : num1; |
|
float y = value1.y; |
|
float num3 = (double) y > (double) max.y? max.y : y; |
|
float num4 = (double) num3 < (double) min.y? min.y : num3; |
|
result.x = num2; |
|
result.y = num4; |
|
} |
|
|
|
public static Vector2 Lerp(Vector2 value1, Vector2 value2, float amount) |
|
{ |
|
Vector2 vector2; |
|
vector2.x = value1.x + (value2.x - value1.x) * amount; |
|
vector2.y = value1.y + (value2.y - value1.y) * amount; |
|
return vector2; |
|
} |
|
|
|
public static void Lerp(ref Vector2 value1, ref Vector2 value2, float amount, out Vector2 result) |
|
{ |
|
result.x = value1.x + (value2.x - value1.x) * amount; |
|
result.y = value1.y + (value2.y - value1.y) * amount; |
|
} |
|
|
|
public static Vector2 SmoothStep(Vector2 value1, Vector2 value2, float amount) |
|
{ |
|
amount = (double) amount > 1.0? 1f : ((double) amount < 0.0? 0.0f : amount); |
|
amount = (float) (amount * (double) amount * (3.0 - 2.0 * amount)); |
|
Vector2 vector2; |
|
vector2.x = value1.x + (value2.x - value1.x) * amount; |
|
vector2.y = value1.y + (value2.y - value1.y) * amount; |
|
return vector2; |
|
} |
|
|
|
public static void SmoothStep(ref Vector2 value1, ref Vector2 value2, float amount, out Vector2 result) |
|
{ |
|
amount = (double) amount > 1.0? 1f : ((double) amount < 0.0? 0.0f : amount); |
|
amount = (float) (amount * (double) amount * (3.0 - 2.0 * amount)); |
|
result.x = value1.x + (value2.x - value1.x) * amount; |
|
result.y = value1.y + (value2.y - value1.y) * amount; |
|
} |
|
|
|
public static Vector2 Negate(Vector2 value) |
|
{ |
|
Vector2 vector2; |
|
vector2.x = -value.x; |
|
vector2.y = -value.y; |
|
return vector2; |
|
} |
|
|
|
public static void Negate(ref Vector2 value, out Vector2 result) |
|
{ |
|
result.x = -value.x; |
|
result.y = -value.y; |
|
} |
|
|
|
public static float Dot(Vector2 value1, Vector2 value2) |
|
{ |
|
return (float) (value1.x * (double) value2.x + value1.y * (double) value2.y); |
|
} |
|
|
|
public static void Dot(ref Vector2 value1, ref Vector2 value2, out float result) |
|
{ |
|
result = (float) (value1.x * (double) value2.x + value1.y * (double) value2.y); |
|
} |
|
|
|
public static float Angle(Vector2 from, Vector2 to) |
|
{ |
|
from.Normalize(); |
|
to.Normalize(); |
|
float result; |
|
Vector2.Dot(ref from, ref to, out result); |
|
return Mathf.Cos(Mathf.Clamp(result, -1f, 1f)) * 57.29578f; |
|
} |
|
|
|
public static void Angle(ref Vector2 from, ref Vector2 to, out float result) |
|
{ |
|
from.Normalize(); |
|
to.Normalize(); |
|
float result1; |
|
Vector2.Dot(ref from, ref to, out result1); |
|
result = Mathf.Cos(Mathf.Clamp(result1, -1f, 1f)) * 57.29578f; |
|
} |
|
|
|
public static Vector2 Add(Vector2 value1, Vector2 value2) |
|
{ |
|
Vector2 vector2; |
|
vector2.x = value1.x + value2.x; |
|
vector2.y = value1.y + value2.y; |
|
return vector2; |
|
} |
|
|
|
public static void Add(ref Vector2 value1, ref Vector2 value2, out Vector2 result) |
|
{ |
|
result.x = value1.x + value2.x; |
|
result.y = value1.y + value2.y; |
|
} |
|
|
|
public static Vector2 Sub(Vector2 value1, Vector2 value2) |
|
{ |
|
Vector2 vector2; |
|
vector2.x = value1.x - value2.x; |
|
vector2.y = value1.y - value2.y; |
|
return vector2; |
|
} |
|
|
|
public static void Sub(ref Vector2 value1, ref Vector2 value2, out Vector2 result) |
|
{ |
|
result.x = value1.x - value2.x; |
|
result.y = value1.y - value2.y; |
|
} |
|
|
|
public static Vector2 Multiply(Vector2 value1, Vector2 value2) |
|
{ |
|
Vector2 vector2; |
|
vector2.x = value1.x * value2.x; |
|
vector2.y = value1.y * value2.y; |
|
return vector2; |
|
} |
|
|
|
public static void Multiply(ref Vector2 value1, ref Vector2 value2, out Vector2 result) |
|
{ |
|
result.x = value1.x * value2.x; |
|
result.y = value1.y * value2.y; |
|
} |
|
|
|
public static Vector2 Multiply(Vector2 value1, float scaleFactor) |
|
{ |
|
Vector2 vector2; |
|
vector2.x = value1.x * scaleFactor; |
|
vector2.y = value1.y * scaleFactor; |
|
return vector2; |
|
} |
|
|
|
public static void Multiply(ref Vector2 value1, float scaleFactor, out Vector2 result) |
|
{ |
|
result.x = value1.x * scaleFactor; |
|
result.y = value1.y * scaleFactor; |
|
} |
|
|
|
public static Vector2 Divide(Vector2 value1, Vector2 value2) |
|
{ |
|
Vector2 vector2; |
|
vector2.x = value1.x / value2.x; |
|
vector2.y = value1.y / value2.y; |
|
return vector2; |
|
} |
|
|
|
public static void Divide(ref Vector2 value1, ref Vector2 value2, out Vector2 result) |
|
{ |
|
result.x = value1.x / value2.x; |
|
result.y = value1.y / value2.y; |
|
} |
|
|
|
public static Vector2 Divide(Vector2 value1, float divider) |
|
{ |
|
float num = 1f / divider; |
|
Vector2 vector2; |
|
vector2.x = value1.x * num; |
|
vector2.y = value1.y * num; |
|
return vector2; |
|
} |
|
|
|
public static void Divide(ref Vector2 value1, float divider, out Vector2 result) |
|
{ |
|
float num = 1f / divider; |
|
result.x = value1.x * num; |
|
result.y = value1.y * num; |
|
} |
|
|
|
public static Vector2 operator -(Vector2 value) |
|
{ |
|
Vector2 vector2; |
|
vector2.x = -value.x; |
|
vector2.y = -value.y; |
|
return vector2; |
|
} |
|
|
|
public static bool operator ==(Vector2 lhs, Vector2 rhs) |
|
{ |
|
return (lhs - rhs).sqrMagnitude < 9.99999943962493E-11; |
|
} |
|
|
|
public static bool operator !=(Vector2 lhs, Vector2 rhs) |
|
{ |
|
return !(lhs == rhs); |
|
} |
|
|
|
public static Vector2 operator +(Vector2 value1, Vector2 value2) |
|
{ |
|
Vector2 vector2; |
|
vector2.x = value1.x + value2.x; |
|
vector2.y = value1.y + value2.y; |
|
return vector2; |
|
} |
|
|
|
public static Vector2 operator -(Vector2 value1, Vector2 value2) |
|
{ |
|
Vector2 vector2; |
|
vector2.x = value1.x - value2.x; |
|
vector2.y = value1.y - value2.y; |
|
return vector2; |
|
} |
|
|
|
public static Vector2 operator *(Vector2 value1, Vector2 value2) |
|
{ |
|
Vector2 vector2; |
|
vector2.x = value1.x * value2.x; |
|
vector2.y = value1.y * value2.y; |
|
return vector2; |
|
} |
|
|
|
public static Vector2 operator *(Vector2 value, float scaleFactor) |
|
{ |
|
Vector2 vector2; |
|
vector2.x = value.x * scaleFactor; |
|
vector2.y = value.y * scaleFactor; |
|
return vector2; |
|
} |
|
|
|
public static Vector2 operator *(float scaleFactor, Vector2 value) |
|
{ |
|
Vector2 vector2; |
|
vector2.x = value.x * scaleFactor; |
|
vector2.y = value.y * scaleFactor; |
|
return vector2; |
|
} |
|
|
|
public static Vector2 operator /(Vector2 value1, Vector2 value2) |
|
{ |
|
Vector2 vector2; |
|
vector2.x = value1.x / value2.x; |
|
vector2.y = value1.y / value2.y; |
|
return vector2; |
|
} |
|
|
|
public static Vector2 operator /(Vector2 value1, float divider) |
|
{ |
|
float num = 1f / divider; |
|
Vector2 vector2; |
|
vector2.x = value1.x * num; |
|
vector2.y = value1.y * num; |
|
return vector2; |
|
} |
|
} |
|
} |