Vector3

Vector3(float x, float y, float z)

Vector3(float x, float y)

const float kEpsilon

const float kEpsilonNormalSqrt

float x

float y

float z

static Vector3 back { get; }

static Vector3 down { get; }

static Vector3 forward { get; }

static Vector3 left { get; }

float magnitude { get; }

static Vector3 negativeInfinity { get; }

Vector3 normalized { get; }

static Vector3 one { get; }

static Vector3 positiveInfinity { get; }

static Vector3 right { get; }

float sqrMagnitude { get; }

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

static Vector3 up { get; }

static Vector3 zero { get; }

static float Angle(Vector3 from, Vector3 to)

static float Angle(in Vector3 from, in Vector3 to)

Unsigned angle in degrees, 0 if either vector is (nearly) zero.

static Vector3 ClampMagnitude(Vector3 vector, float maxLength)

static Vector3 ClampMagnitude(in Vector3 vector, float maxLength)

static Vector3 Cross(Vector3 lhs, Vector3 rhs)

static Vector3 Cross(in Vector3 lhs, in Vector3 rhs)

static float Distance(Vector3 a, Vector3 b)

static float Distance(in Vector3 a, in Vector3 b)

static float Dot(Vector3 lhs, Vector3 rhs)

static float Dot(in Vector3 lhs, in Vector3 rhs)

bool Equals(Vector3 other)

bool Equals(in Vector3 other)

bool Equals(object? other)

int GetHashCode()

static Vector3 Lerp(Vector3 a, Vector3 b, float t)

static Vector3 Lerp(in Vector3 a, in Vector3 b, float t)

static Vector3 LerpUnclamped(Vector3 a, Vector3 b, float t)

static Vector3 LerpUnclamped(in Vector3 a, in Vector3 b, float t)

static Vector3 Max(Vector3 a, Vector3 b)

static Vector3 Max(in Vector3 a, in Vector3 b)

static Vector3 Min(Vector3 a, Vector3 b)

static Vector3 Min(in Vector3 a, in Vector3 b)

static Vector3 MoveTowards(Vector3 current, Vector3 target, float maxDistanceDelta)

static Vector3 MoveTowards(in Vector3 current, in Vector3 target, float maxDistanceDelta)

void Normalize()

static Vector3 Normalize(Vector3 value)

static Vector3 Normalize(in Vector3 value)

Unit vector, or zero if the magnitude is at most kEpsilon.

static void OrthoNormalize(ref Vector3 normal, ref Vector3 tangent)

static void OrthoNormalize(ref Vector3 normal, ref Vector3 tangent, ref Vector3 binormal)

static Vector3 Project(Vector3 vector, Vector3 onNormal)

static Vector3 Project(in Vector3 vector, in Vector3 onNormal)

static Vector3 ProjectOnPlane(Vector3 vector, Vector3 planeNormal)

static Vector3 ProjectOnPlane(in Vector3 vector, in Vector3 planeNormal)

static Vector3 Reflect(Vector3 inDirection, Vector3 inNormal)

static Vector3 Reflect(in Vector3 inDirection, in Vector3 inNormal)

static Vector3 RotateTowards(Vector3 current, Vector3 target, float maxRadiansDelta, float maxMagnitudeDelta)

static Vector3 RotateTowards(in Vector3 current, in Vector3 target, float maxRadiansDelta, float maxMagnitudeDelta)

Rotates current towards target by at most maxRadiansDelta, changing its magnitude by at most maxMagnitudeDelta.

void Scale(Vector3 scale)

void Scale(in Vector3 scale)

static Vector3 Scale(Vector3 a, Vector3 b)

static Vector3 Scale(in Vector3 a, in Vector3 b)

void Set(float newX, float newY, float newZ)

static float SignedAngle(Vector3 from, Vector3 to, Vector3 axis)

static float SignedAngle(in Vector3 from, in Vector3 to, in Vector3 axis)

Angle with the sign of the rotation around axis.

static Vector3 Slerp(Vector3 a, Vector3 b, float t)

static Vector3 Slerp(in Vector3 a, in Vector3 b, float t)

Interpolates direction (on the sphere) and magnitude separately.

static Vector3 SlerpUnclamped(Vector3 a, Vector3 b, float t)

static Vector3 SlerpUnclamped(in Vector3 a, in Vector3 b, float t)

static Vector3 SmoothDamp(Vector3 current, Vector3 target, ref Vector3 currentVelocity, float smoothTime)

static Vector3 SmoothDamp(in Vector3 current, in Vector3 target, ref Vector3 currentVelocity, float smoothTime)

static Vector3 SmoothDamp(Vector3 current, Vector3 target, ref Vector3 currentVelocity, float smoothTime, float maxSpeed)

static Vector3 SmoothDamp(in Vector3 current, in Vector3 target, ref Vector3 currentVelocity, float smoothTime, float maxSpeed)

static Vector3 SmoothDamp(Vector3 current, Vector3 target, ref Vector3 currentVelocity, float smoothTime, float maxSpeed, float deltaTime)

static Vector3 SmoothDamp(in Vector3 current, in Vector3 target, ref Vector3 currentVelocity, float smoothTime, float maxSpeed, float deltaTime)

Vector version of Mathf.SmoothDamp; maxSpeed limits the magnitude.

string ToString()

string ToString(string? format)

string ToString(string? format, IFormatProvider? formatProvider)

static bool operator !=(Vector3 lhs, Vector3 rhs)

static Vector3 operator *(Vector3 a, float d)

static Vector3 operator *(float d, Vector3 a)

static Vector3 operator +(Vector3 a, Vector3 b)

static Vector3 operator -(Vector3 a, Vector3 b)

static Vector3 operator -(Vector3 a)

static Vector3 operator /(Vector3 a, float d)

static bool operator ==(Vector3 lhs, Vector3 rhs)

Approximate: true if the vectors are within 1e-5 of each other.