public sealed struct Vector3

public Vector3 AddClamped(Vector3 toAdd, float maxLength)

Try to add to this vector. If we're already over max then don't add. If we're over max when we add, clamp in that direction so we're not.

public bool AlmostEqual(Vector3 v, float delta = 0.0001)

Returns true if we're nearly equal to the passed vector.

public float Angle(Vector3 other)

Return the distance between the two direction vectors in degrees.

public Vector3 Approach(float length, float amount)

Returns a new vector whose length is closer to given target length by given amount.

public static Vector3 CatmullRomSpline(Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3, float t)

Calculates a point on a Catmull-Rom spline given four control points and a parameter t.

public Vector3 ComponentMax(Vector3 other)

Returns a vector that has the maximum values on each axis between this vector and given vector.

public Vector3 ComponentMin(Vector3 other)

Returns a vector that has the minimum values on each axis between this vector and given vector.

public static Vector3 CubicBezier(Vector3 source, Vector3 target, Vector3 sourceTangent, Vector3 targetTangent, float t)

Calculates position of a point on a cubic beizer curve at given fraction.

public static Vector3 Direction(Vector3 from, Vector3 to)

Calculates the normalized direction vector from one point to another in 3D space.

public float Distance(Vector3 target)

Returns distance between this vector to given vector.

public static float DistanceBetween(Vector3 a, Vector3 b)

Returns distance between the 2 given vectors.

public static float DistanceBetweenSquared(Vector3 a, Vector3 b)

Returns squared distance between the 2 given vectors. This is faster than DistanceBetween, and can be used for things like comparing distances, as long as only squared values are used.

public float DistanceSquared(Vector3 target)

Returns squared distance between this vector to given vector. This is faster than Distance, and can be used for things like comparing distances, as long as only squared values are used.

public static float GetAngle(Vector3 v1, Vector3 v2)

Return the distance between the two direction vectors in degrees.

public static float InverseLerp(Vector3 pos, Vector3 a, Vector3 b, bool clamp = True)

Given a position, and two other positions, calculate the inverse lerp position between those

public bool IsNearlyZero(float tolerance = 0.0001)

Returns true if value on every axis is less than tolerance away from zero

public static Vector3 Max(Vector3 a, Vector3 b)

Returns a vector that has the maximum values on each axis between the 2 given vectors.

public static Vector3 Min(Vector3 a, Vector3 b)

Returns a vector that has the minimum values on each axis between the 2 given vectors.

public Vector3 ProjectOnNormal(Vector3 normal)

Projects this vector onto another vector. Basically extends the given normal/unit vector to be as long as necessary to make a right triangle (a triangle which has a 90 degree corner) between (0,0,0), this vector and the projected vector.

public static Vector3 Reflect(Vector3 direction, Vector3 normal)

Returns a reflected vector based on incoming direction and plane normal. Like a ray reflecting off of a mirror.

public Vector3 RotateAround(Vector3 center, Rotation rot)

Rotate this vector around given point by given rotation and return the result as a new vector. See `Transform.RotateAround(Vector3@,Rotation@)` for similar method that also transforms rotation.

public static Vector3 Slerp(Vector3 a, Vector3 b, float frac, bool clamp = True)

Performs spherical linear interpolation (Slerp) between two vectors.

public Vector3 SlerpTo(Vector3 target, float frac, bool clamp = True)

Performs spherical linear interpolation (Slerp) between this vector and a target vector.

public static Vector3 SmoothDamp(Vector3 current, Vector3 target, Vector3 velocity, float smoothTime, float deltaTime)

Smoothly move towards the target vector

public Vector3 SnapToGrid(float gridSize, bool sx = True, bool sy = True, bool sz = True)

Snap to grid along any of the 3 axes.

public static void Sort(Vector3 min, Vector3 max)

Sort these two vectors into min and max. This doesn't just swap the vectors, it sorts each component. So that min will come out containing the minimum x, y and z values.

public Vector3 SubtractDirection(Vector3 direction, float strength = 1)

Given a vector like 1,1,1 and direction 1,0,0, will return 0,1,1. This is useful for velocity collision type events, where you want to cancel out velocity based on a normal. For this to work properly, direction should be a normal, but you can scale how much you want to subtract by scaling the direction. Ie, passing in a direction with a length of 0.5 will remove half the direction.

public static Vector3 TcbSpline(Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3, float tension, float continuity, float bias, float u)

Calculates an interpolated point using the Kochanek-Bartels spline (TCB spline).

public static Angles VectorAngle(Vector3 vec)

Converts a direction vector to an angle.

public static Vector3 VectorPlaneProject(Vector3 v, Vector3 planeNormal)

Projects given vector on a plane defined by `planeNormal`.

public Vector3 WithAcceleration(Vector3 target, float acceleration)

Move to the target vector, by amount acceleration

public Vector3 WithFriction(float frictionAmount, float stopSpeed = 140)

Apply an amount of friction to the current velocity.

public Vector3 WithX(float x)

Returns this vector with given X component.

public Vector3 WithY(float y)

Returns this vector with given Y component.

public Vector3 WithZ(float z)

Returns this vector with given Z component.

public Angles Vector3.EulerAngles { get; set; }

The Euler angles of this direction vector.

public Vector3 Vector3.Inverse { get; set; }

Returns the inverse of this vector, which is useful for scaling vectors.

public bool Vector3.IsInfinity { get; set; }

Returns true if x, y or z are infinity

public bool Vector3.IsNaN { get; set; }

Returns true if x, y or z are NaN

public bool Vector3.IsNearZeroLength { get; set; }

Returns true if the squared length is less than 1e-8 (which is really near zero)

public float Vector3.Item { get; set; }

public float Vector3.Length { get; set; }

Length (or magnitude) of the vector (Distance from 0,0,0).

public float Vector3.LengthSquared { get; set; }

Squared length of the vector. This is faster than Length, and can be used for things like comparing distances, as long as only squared values are used.

public Vector3 Vector3.Normal { get; set; }

Returns a unit version of this vector. A unit vector has length of 1.

public static Vector3 Vector3.Random { get; set; }

Uniformly samples a 3D position from all points with distance at most 1 from the origin.

public float Vector3.x { get; set; }

The X component of this vector.

public float Vector3.y { get; set; }

The Y component of this vector.

public float Vector3.z { get; set; }

The Z component of this vector.