Vector2

public Vector2(float x, float y);

Constructs a new Vector2 from the given Vector2.X and Vector2.Y.

public static Vector2 Down { get; }

Down unit vector. Y is down in 2D, so this vector points +Y.

public static Vector2 Inf { get; }

Infinity vector, a vector with all components set to @C#.INF.

public float this[int index] { get; set; }

Access vector components using their index.

public static Vector2 Left { get; }

Left unit vector. Represents the direction of left.

public static Vector2 One { get; }

One vector, a vector with all components set to 1.

public static Vector2 Right { get; }

Right unit vector. Represents the direction of right.

public static Vector2 Up { get; }

Up unit vector. Y is down in 2D, so this vector points -Y.

public static Vector2 Zero { get; }

Zero vector, a vector with all components set to 0.

public Vector2 Abs();

Returns a new vector with all components in absolute values (i.e. positive).

public float Angle();

Returns Mathf.Atan2(Y, X): the angle in radians relative to the positive X axis. Right has angle 0, and Down (positive Y in the usual 2D screen coordinates) has angle PI / 2.

public float AngleTo(Vector2 to);

Returns a signed radian angle using atan2(Cross, Dot). Right → Down gives π/2, clockwise on a Y-down screen.

public float AngleToPoint(Vector2 to);

Returns Mathf.Atan2(to.Y - Y, to.X - X), the angle in radians of the direction from this point to to. Both points must use the same coordinate system. This does not rotate an Entity or measure an angle between two independent direction vectors.

public float Aspect();

Returns this vector's aspect ratio, which is Vector2.X divided by Vector2.Y.

public Vector2 BezierDerivative(Vector2 control1, Vector2 control2, Vector2 end, float t);

Returns the derivative at the given t on the Bézier curve defined by this vector and the given control_1, control_2, and end points.

public Vector2 BezierInterpolate(Vector2 control1, Vector2 control2, Vector2 end, float t);

Returns the point at the given t on the Bézier curve defined by this vector and the given control_1, control_2, and end points.

public Vector2 Bounce(Vector2 normal);

Bounces velocity off a surface with a unit normal. (1,1) and Up produce (1,−1), opposite to this SDK Reflect result.

public Vector2 Ceil();

Returns a new vector with all components rounded up (towards positive infinity).

public Vector2 Clamp(Vector2 min, Vector2 max);

Returns a new vector with all components clamped between the components of Vector2.Min and Vector2.Max, by running @GlobalScope.clamp on each component.

public Vector2 Clamp(float min, float max);

Returns a new vector with all components clamped between the components of Vector2.Min and Vector2.Max, by running @GlobalScope.clamp on each component.

public float Cross(Vector2 with);

Returns scalar x₁y₂ − y₁x₂, not Vector3. Right.Cross(Down) = 1. Interpret its sign with the screen Y convention.

public Vector2 CubicInterpolate(Vector2 b, Vector2 preA, Vector2 postB, float weight);

Performs a cubic interpolation between this vector and b using pre_a and post_b as handles, and returns the result at position weight. weight is on the range of 0.0 to 1.0, representing the amount of interpolation.

public Vector2 CubicInterpolateInTime(Vector2 b, Vector2 preA, Vector2 postB, float weight, float t, float preAT, float postBT);

Performs a cubic interpolation between this vector and b using pre_a and post_b as handles, and returns the result at position weight. weight is on the range of 0.0 to 1.0, representing the amount of interpolation. It can perform smoother interpolation than Vector2.CubicInterpolate by the time values.

public void Deconstruct(out float x, out float y);

Helper method for deconstruction into a tuple.

public Vector2 DirectionTo(Vector2 to);

Returns the normalized vector pointing from this vector to to. a.direction_to(b) is equivalent to (b - a).normalized(). See also Vector2.Normalized.

public float DistanceSquaredTo(Vector2 to);

Returns the squared Euclidean distance between this vector and to. This method runs faster than Vector2.DistanceTo, so prefer it if you need to compare vectors or need the squared distance for some formula.

public float DistanceTo(Vector2 to);

Returns the Euclidean distance between this vector and to.

public float Dot(Vector2 with);

Dot product. For unit directions it is the angle cosine; otherwise it also includes both magnitudes.

public bool Equals(Vector2 other);

Returns true if the vectors are exactly equal. Note: Due to floating-point precision errors, consider using Vector2.IsEqualApprox instead, which is more reliable.

public override bool Equals(object? obj);

Returns true if the vector is exactly equal to the given object (obj). Note: Due to floating-point precision errors, consider using Vector2.IsEqualApprox instead, which is more reliable.

public Vector2 Floor();

Returns a new vector with all components rounded down (towards negative infinity).

public static Vector2 FromAngle(float angle);

Creates a Vector2 rotated to the given Vector2.Angle in radians. This is equivalent to doing Vector2(cos(angle), sin(angle)) or Vector2.RIGHT.rotated(angle).

print(Vector2.from_angle(0)) # Prints (1.0, 0.0)
print(Vector2(1, 0).angle()) # Prints 0.0, which is the angle used above.
print(Vector2.from_angle(PI / 2)) # Prints (0.0, 1.0)

Note: The length of the returned Vector2 is approximately 1.0, but is is not guaranteed to be exactly 1.0 due to floating-point precision issues. Call Vector2.Normalized on the returned Vector2 if you require a unit vector.

public override int GetHashCode();

Serves as the hash function for Vector2.

public Vector2 Inverse();

Returns the inverse of the vector. This is the same as Vector2(1.0 / v.x, 1.0 / v.y).

public bool IsEqualApprox(Vector2 other);

Returns true if this vector and to are approximately equal, by running @GlobalScope.is_equal_approx on each component.

public bool IsFinite();

Returns true if this vector is finite, by calling @GlobalScope.is_finite on each component.

public bool IsNormalized();

Returns true if the vector is normalized, i.e. its length is approximately equal to 1.

public bool IsZeroApprox();

Returns true if this vector's values are approximately zero, by running @GlobalScope.is_zero_approx on each component. This method is faster than using Vector2.IsEqualApprox with one value as a zero vector.

public float Length();

Returns the length (magnitude) of this vector.

public float LengthSquared();

Returns the squared length (squared magnitude) of this vector. This method runs faster than Vector2.Length, so prefer it if you need to compare vectors or need the squared distance for some formula.

public Vector2 Lerp(Vector2 to, float weight);

Interpolates linearly by weight. 0/1 give endpoints; out-of-range values can extrapolate. Weight is neither distance nor time.

public Vector2 LimitLength(float length = 1f);

Returns the vector with a maximum length by limiting its length to Vector2.Length. If the vector is non-finite, the result is undefined.

public Vector2 Max(Vector2 with);

Returns the component-wise maximum of this and with, equivalent to Vector2(maxf(x, with.x), maxf(y, with.y)).

public Vector2 Max(float with);

Returns the component-wise maximum of this and with, equivalent to Vector2(maxf(x, with.x), maxf(y, with.y)).

public Vector2.Axis MaxAxisIndex();

Returns the axis of the vector's highest value. See AXIS_* constants. If all components are equal, this method returns Vector2.Axis.X.

public Vector2 Min(Vector2 with);

Returns the component-wise minimum of this and with, equivalent to Vector2(minf(x, with.x), minf(y, with.y)).

public Vector2 Min(float with);

Returns the component-wise minimum of this and with, equivalent to Vector2(minf(x, with.x), minf(y, with.y)).

public Vector2.Axis MinAxisIndex();

Returns the axis of the vector's lowest value. See AXIS_* constants. If all components are equal, this method returns Vector2.Axis.Y.

public Vector2 MoveToward(Vector2 to, float delta);

For finite delta ≥ 0, approaches without overshoot; a distance below Mathf.Epsilon snaps to the target. Negative delta normally moves away. For speed per second, pass speed × timestep.

public Vector2 Normalized();

Returns unit direction, or Zero for a zero vector. Removes displacement magnitude; Zero does not define an aiming angle.

public Vector2 Orthogonal();

Returns a perpendicular vector rotated 90 degrees counter-clockwise compared to the original, with the same length.

public Vector2 PosMod(Vector2 modv);

Returns a vector composed of the @GlobalScope.fposmod of this vector's components and mod.

public Vector2 PosMod(float mod);

Returns a vector composed of the @GlobalScope.fposmod of this vector's components and mod.

public Vector2 Project(Vector2 onNormal);

Returns a new vector resulting from projecting this vector onto the given vector b. The resulting new vector is parallel to b. See also Vector2.Slide. Note: If the vector b is a zero vector, the components of the resulting new vector will be @C#.NAN.

public Vector2 Reflect(Vector2 normal);

Computes 2 × dot(v,n) × n − v for unit n. This is negative Bounce; use Bounce for ordinary surface bouncing.

public Vector2 Rotated(float angle);

Returns the result of rotating this vector by Vector2.Angle (in radians). See also @GlobalScope.deg_to_rad.

public Vector2 Round();

Returns a new vector with all components rounded to the nearest integer, with halfway cases rounded away from zero.

public Vector2 Sign();

Returns a new vector with each component set to 1.0 if it's positive, -1.0 if it's negative, and 0.0 if it's zero. The result is identical to calling @GlobalScope.sign on each component.

public Vector2 Slerp(Vector2 to, float weight);

Returns the result of spherical linear interpolation between this vector and to, by amount weight. weight is on the range of 0.0 to 1.0, representing the amount of interpolation. This method also handles interpolating the lengths if the input vectors have different lengths. For the special case of one or both input vectors having zero length, this method behaves like Vector2.Lerp.

public Vector2 Slide(Vector2 normal);

Returns a new vector resulting from sliding this vector along a line with normal n. The resulting new vector is perpendicular to n, and is equivalent to this vector minus its projection on n. See also Vector2.Project. Note: The vector n must be normalized. See also Vector2.Normalized.

public Vector2 Snapped(Vector2 step);

Returns a new vector with each component snapped to the nearest multiple of the corresponding component in step. This can also be used to round the components to an arbitrary number of decimals.

public Vector2 Snapped(float step);

Returns a new vector with each component snapped to the nearest multiple of the corresponding component in step. This can also be used to round the components to an arbitrary number of decimals.

public override string ToString();

Converts this Vector2 to a string.

public string ToString(string? format);

Converts this Vector2 to a string with the given format.

public static Vector2 operator +(Vector2 left, Vector2 right);

Adds each component of the Vector2 with the components of the given Vector2.

public static Vector2 operator /(Vector2 vec, Vector2 divisorv);

Divides each component of the Vector2 by the components of the given Vector2.

public static Vector2 operator /(Vector2 vec, float divisor);

Divides each component of the Vector2 by the given System.Single.

public static bool operator ==(Vector2 left, Vector2 right);

Returns true if the vectors are exactly equal. Note: Due to floating-point precision errors, consider using Vector2.IsEqualApprox instead, which is more reliable.

public static bool operator >(Vector2 left, Vector2 right);

Compares two Vector2 vectors by first checking if the X value of the left vector is greater than the X value of the right vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors. This operator is useful for sorting vectors.

public static bool operator >=(Vector2 left, Vector2 right);

Compares two Vector2 vectors by first checking if the X value of the left vector is greater than or equal to the X value of the right vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors. This operator is useful for sorting vectors.

public static bool operator !=(Vector2 left, Vector2 right);

Returns true if the vectors are not equal. Note: Due to floating-point precision errors, consider using Vector2.IsEqualApprox instead, which is more reliable.

public static bool operator <(Vector2 left, Vector2 right);

Compares two Vector2 vectors by first checking if the X value of the left vector is less than the X value of the right vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors. This operator is useful for sorting vectors.

public static bool operator <=(Vector2 left, Vector2 right);

Compares two Vector2 vectors by first checking if the X value of the left vector is less than or equal to the X value of the right vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors. This operator is useful for sorting vectors.

public static Vector2 operator %(Vector2 vec, Vector2 divisorv);

Gets the remainder of each component of the Vector2 with the components of the given Vector2. This operation uses truncated division, which is often not desired as it does not work well with negative numbers. Consider using Vector2.PosMod instead if you want to handle negative numbers.

public static Vector2 operator %(Vector2 vec, float divisor);

Gets the remainder of each component of the Vector2 with the components of the given System.Single. This operation uses truncated division, which is often not desired as it does not work well with negative numbers. Consider using Vector2.PosMod instead if you want to handle negative numbers.

public static Vector2 operator *(Vector2 left, Vector2 right);

Multiplies each component of the Vector2 by the components of the given Vector2.

public static Vector2 operator *(Vector2 vec, float scale);

Multiplies each component of the Vector2 by the given System.Single.

public static Vector2 operator *(float scale, Vector2 vec);

Multiplies each component of the Vector2 by the given System.Single.

public static Vector2 operator -(Vector2 left, Vector2 right);

Subtracts each component of the Vector2 by the components of the given Vector2.

public static Vector2 operator -(Vector2 vec);

Returns the negative value of the Vector2. This is the same as writing new Vector2(-v.X, -v.Y). This operation flips the direction of the vector while keeping the same magnitude. With floats, the number zero can be either positive or negative.

public static Vector2 operator +(Vector2 vec);

Returns the same value as if the + was not there. Unary + does nothing, but sometimes it can make your code more readable.

public float X;

The vector's X component. Also accessible by using the index position [0].

public float Y;

The vector's Y component. Also accessible by using the index position [1].