Vector3

public Vector3(float x, float y, float z);

Returns a Vector3 with the given components.

public static Vector3 Back { get; }

Back unit vector. Represents the local direction of back, and the global direction of south.

public static Vector3 Down { get; }

Down unit vector.

public static Vector3 Forward { get; }

Forward unit vector. Represents the local direction of forward, and the global direction of north. Keep in mind that the forward direction for lights, cameras, etc is different from 3D assets like characters, which face towards the camera by convention. Use Vector3.ModelFront and similar constants when working in 3D asset space.

public static Vector3 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 Vector3 Left { get; }

Left unit vector. Represents the local direction of left, and the global direction of west.

public static Vector3 ModelBottom { get; }

Unit vector pointing towards the bottom side (down) of imported 3D assets.

public static Vector3 ModelFront { get; }

Unit vector pointing towards the front side (facing forward) of imported 3D assets.

public static Vector3 ModelLeft { get; }

Unit vector pointing towards the left side of imported 3D assets.

public static Vector3 ModelRear { get; }

Unit vector pointing towards the rear side (back) of imported 3D assets.

public static Vector3 ModelRight { get; }

Unit vector pointing towards the right side of imported 3D assets.

public static Vector3 ModelTop { get; }

Unit vector pointing towards the top side (up) of imported 3D assets.

public static Vector3 One { get; }

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

public static Vector3 Right { get; }

Right unit vector. Represents the local direction of right, and the global direction of east.

public static Vector3 Up { get; }

Up unit vector.

public static Vector3 Zero { get; }

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

public Vector3 Abs();

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

public float AngleTo(Vector3 to);

Returns the unsigned minimum angle to the given vector, in radians.

public Vector3 BezierDerivative(Vector3 control1, Vector3 control2, Vector3 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 Vector3 BezierInterpolate(Vector3 control1, Vector3 control2, Vector3 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 Vector3 Bounce(Vector3 normal);

Returns the vector "bounced off" from a plane defined by the given normal n. Note: Vector3.Bounce performs the operation that most engines and frameworks call [code skip-lint]reflect()`.

public Vector3 Ceil();

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

public Vector3 Clamp(Vector3 min, Vector3 max);

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

public Vector3 Clamp(float min, float max);

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

public Vector3 Cross(Vector3 with);

Returns a perpendicular vector whose magnitude depends on input lengths and angle. Right.Cross(Up) = Back (+Z); Reckfell Forward is −Z.

public Vector3 CubicInterpolate(Vector3 b, Vector3 preA, Vector3 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 Vector3 CubicInterpolateInTime(Vector3 b, Vector3 preA, Vector3 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 Vector3.CubicInterpolate by the time values.

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

Helper method for deconstruction into a tuple.

public Vector3 DirectionTo(Vector3 to);

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

public float DistanceSquaredTo(Vector3 to);

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

public float DistanceTo(Vector3 to);

Returns the Euclidean distance between this vector and to.

public float Dot(Vector3 with);

Returns the dot product of this vector and with. This can be used to compare the angle between two vectors. For example, this can be used to determine whether an enemy is facing the player. The dot product will be 0 for a right angle (90 degrees), greater than 0 for angles narrower than 90 degrees and lower than 0 for angles wider than 90 degrees. When using unit (normalized) vectors, the result will always be between -1.0 (180 degree angle) when the vectors are facing opposite directions, and 1.0 (0 degree angle) when the vectors are aligned. Note: a.dot(b) is equivalent to b.dot(a).

public bool Equals(Vector3 other);

Returns true if the vectors are exactly equal. Note: Due to floating-point precision errors, consider using Vector3.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 Vector3.IsEqualApprox instead, which is more reliable.

public Vector3 Floor();

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

public override int GetHashCode();

Serves as the hash function for Vector3.

public Vector3 Inverse();

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

public bool IsEqualApprox(Vector3 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 Vector3.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 Vector3.Length, so prefer it if you need to compare vectors or need the squared distance for some formula.

public Vector3 Lerp(Vector3 to, float weight);

Returns the result of the 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.

public Vector3 LimitLength(float length = 1f);

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

public Vector3 Max(Vector3 with);

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

public Vector3 Max(float with);

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

public Vector3.Axis MaxAxisIndex();

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

public Vector3 Min(Vector3 with);

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

public Vector3 Min(float with);

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

public Vector3.Axis MinAxisIndex();

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

public Vector3 MoveToward(Vector3 to, float delta);

Returns a new vector moved toward to by the fixed delta amount. Will not go past the final value.

public Vector3 Normalized();

Returns the result of scaling the vector to unit length. Equivalent to v / v.length(). Returns (0, 0, 0) if v.length() == 0. See also Vector3.IsNormalized. Note: This function may return incorrect values if the input vector length is near zero.

public static Vector3 OctahedronDecode(Vector2 oct);

Returns the Vector3 from an octahedral-compressed form created using Vector3.OctahedronEncode (stored as a Vector2).

public Vector2 OctahedronEncode();

Returns the octahedral-encoded (oct32) form of this Vector3 as a Vector2. Since a Vector2 occupies 1/3 less memory compared to Vector3, this form of compression can be used to pass greater amounts of Vector3.Normalized Vector3s without increasing storage or memory requirements. See also Vector3.OctahedronDecode. Note: Vector3.OctahedronEncode can only be used for Vector3.Normalized vectors. Vector3.OctahedronEncode does not check whether this Vector3 is normalized, and will return a value that does not decompress to the original value if the Vector3 is not normalized. Note: Octahedral compression is lossy, although visual differences are rarely perceptible in real world scenarios.

public Basis Outer(Vector3 with);

Returns the outer product with with.

public Vector3 PosMod(Vector3 modv);

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

public Vector3 PosMod(float mod);

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

public Vector3 Project(Vector3 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 Vector3.Slide. Note: If the vector b is a zero vector, the components of the resulting new vector will be @C#.NAN.

public Vector3 Reflect(Vector3 normal);

Returns the result of reflecting the vector through a plane defined by the given normal vector n. Note: Vector3.Reflect differs from what other engines and frameworks call Vector3.Bounce which does what most engines call [code skip-lint]reflect()`.

public Vector3 Rotated(Vector3 axis, float angle);

Returns the result of rotating this vector around a given axis by angle (in radians). The axis must be a normalized vector. See also @GlobalScope.deg_to_rad.

public Vector3 Round();

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

public Vector3 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 float SignedAngleTo(Vector3 to, Vector3 axis);

Returns the signed angle to the given vector, in radians. The sign of the angle is positive in a counter-clockwise direction and negative in a clockwise direction when viewed from the side specified by the axis.

public Vector3 Slerp(Vector3 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 Vector3.Lerp.

public Vector3 Slide(Vector3 normal);

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

public Vector3 Snapped(Vector3 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 Vector3 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 Vector3 to a string.

public string ToString(string? format);

Converts this Vector3 to a string with the given format.

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

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

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

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

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

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

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

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

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

Compares two Vector3 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, and then with the Z values. This operator is useful for sorting vectors.

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

Compares two Vector3 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, and then with the Z values. This operator is useful for sorting vectors.

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

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

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

Compares two Vector3 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, and then with the Z values. This operator is useful for sorting vectors.

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

Compares two Vector3 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, and then with the Z values. This operator is useful for sorting vectors.

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

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

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

Gets the remainder of each component of the Vector3 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 Vector3.PosMod instead if you want to handle negative numbers.

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

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

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

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

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

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

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

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

public static Vector3 operator -(Vector3 vec);

Returns the negative value of the Vector3. This is the same as writing new Vector3(-v.X, -v.Y, -v.Z). 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 Vector3 operator +(Vector3 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].

public float Z;

The vector's Z component. Also accessible by using the index position [2].