# Struct Vector3

- Namespace
- Stride.Core.Mathematics

- Assembly
- Stride.Core.Mathematics.dll

Represents a three dimensional mathematical vector.

```
[DataContract("float3")]
[DataStyle(DataStyle.Compact)]
public struct Vector3 : IEquatable<Vector3>, IFormattable
```

- Implements

- Extension Methods

## Constructors

### Vector3(Vector2, float)

Initializes a new instance of the Vector3 struct.

`public Vector3(Vector2 value, float z)`

#### Parameters

`value`

Vector2A vector containing the values with which to initialize the X and Y components.

`z`

floatInitial value for the Z component of the vector.

### Vector3(float)

Initializes a new instance of the Vector3 struct.

`public Vector3(float value)`

#### Parameters

`value`

floatThe value that will be assigned to all components.

### Vector3(float, float, float)

Initializes a new instance of the Vector3 struct.

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

#### Parameters

`x`

floatInitial value for the X component of the vector.

`y`

floatInitial value for the Y component of the vector.

`z`

floatInitial value for the Z component of the vector.

### Vector3(float[])

Initializes a new instance of the Vector3 struct.

`public Vector3(float[] values)`

#### Parameters

`values`

float[]The values to assign to the X, Y, and Z components of the vector. This must be an array with three elements.

#### Exceptions

- ArgumentNullException
Thrown when

`values`

is`null`

.- ArgumentOutOfRangeException
Thrown when

`values`

contains more or less than three elements.

## Fields

### One

A Vector3 with all of its components set to one.

`public static readonly Vector3 One`

#### Field Value

### SizeInBytes

The size of the Vector3 type, in bytes.

`public static readonly int SizeInBytes`

#### Field Value

### UnitX

The X unit Vector3 (1, 0, 0).

`public static readonly Vector3 UnitX`

#### Field Value

### UnitY

The Y unit Vector3 (0, 1, 0).

`public static readonly Vector3 UnitY`

#### Field Value

### UnitZ

The Z unit Vector3 (0, 0, 1).

`public static readonly Vector3 UnitZ`

#### Field Value

### X

The X component of the vector.

```
[DataMember(0)]
public float X
```

#### Field Value

### Y

The Y component of the vector.

```
[DataMember(1)]
public float Y
```

#### Field Value

### Z

The Z component of the vector.

```
[DataMember(2)]
public float Z
```

#### Field Value

### Zero

A Vector3 with all of its components set to zero.

`public static readonly Vector3 Zero`

#### Field Value

## Properties

### IsNormalized

Gets a value indicting whether this instance is normalized.

`public readonly bool IsNormalized { get; }`

#### Property Value

### this[int]

Gets or sets the component at the specified index.

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

#### Parameters

`index`

intThe index of the component to access. Use 0 for the X component, 1 for the Y component, and 2 for the Z component.

#### Property Value

- float
The value of the X, Y, or Z component, depending on the index.

#### Exceptions

- ArgumentOutOfRangeException
Thrown when the

`index`

is out of the range [0, 2].

## Methods

### Add(Vector3, Vector3)

Adds two vectors.

`public static Vector3 Add(Vector3 left, Vector3 right)`

#### Parameters

#### Returns

- Vector3
The sum of the two vectors.

### Add(ref readonly Vector3, ref readonly Vector3, out Vector3)

Adds two vectors.

`public static void Add(ref readonly Vector3 left, ref readonly Vector3 right, out Vector3 result)`

#### Parameters

`left`

Vector3The first vector to add.

`right`

Vector3The second vector to add.

`result`

Vector3When the method completes, contains the sum of the two vectors.

### Barycentric(Vector3, Vector3, Vector3, float, float)

Returns a Vector3 containing the 3D Cartesian coordinates of a point specified in Barycentric coordinates relative to a 3D triangle.

`public static Vector3 Barycentric(Vector3 value1, Vector3 value2, Vector3 value3, float amount1, float amount2)`

#### Parameters

`value1`

Vector3A Vector3 containing the 3D Cartesian coordinates of vertex 1 of the triangle.

`value2`

Vector3A Vector3 containing the 3D Cartesian coordinates of vertex 2 of the triangle.

`value3`

Vector3A Vector3 containing the 3D Cartesian coordinates of vertex 3 of the triangle.

`amount1`

floatBarycentric coordinate b2, which expresses the weighting factor toward vertex 2 (specified in

`value2`

).`amount2`

floatBarycentric coordinate b3, which expresses the weighting factor toward vertex 3 (specified in

`value3`

).

#### Returns

### Barycentric(ref readonly Vector3, ref readonly Vector3, ref readonly Vector3, float, float, out Vector3)

Returns a Vector3 containing the 3D Cartesian coordinates of a point specified in Barycentric coordinates relative to a 3D triangle.

`public static void Barycentric(ref readonly Vector3 value1, ref readonly Vector3 value2, ref readonly Vector3 value3, float amount1, float amount2, out Vector3 result)`

#### Parameters

`value1`

Vector3A Vector3 containing the 3D Cartesian coordinates of vertex 1 of the triangle.

`value2`

Vector3A Vector3 containing the 3D Cartesian coordinates of vertex 2 of the triangle.

`value3`

Vector3A Vector3 containing the 3D Cartesian coordinates of vertex 3 of the triangle.

`amount1`

floatBarycentric coordinate b2, which expresses the weighting factor toward vertex 2 (specified in

`value2`

).`amount2`

floatBarycentric coordinate b3, which expresses the weighting factor toward vertex 3 (specified in

`value3`

).`result`

Vector3When the method completes, contains the 3D Cartesian coordinates of the specified point.

### CatmullRom(Vector3, Vector3, Vector3, Vector3, float)

Performs a Catmull-Rom interpolation using the specified positions.

`public static Vector3 CatmullRom(Vector3 value1, Vector3 value2, Vector3 value3, Vector3 value4, float amount)`

#### Parameters

`value1`

Vector3The first position in the interpolation.

`value2`

Vector3The second position in the interpolation.

`value3`

Vector3The third position in the interpolation.

`value4`

Vector3The fourth position in the interpolation.

`amount`

floatWeighting factor.

#### Returns

- Vector3
A vector that is the result of the Catmull-Rom interpolation.

### CatmullRom(ref readonly Vector3, ref readonly Vector3, ref readonly Vector3, ref readonly Vector3, float, out Vector3)

Performs a Catmull-Rom interpolation using the specified positions.

`public static void CatmullRom(ref readonly Vector3 value1, ref readonly Vector3 value2, ref readonly Vector3 value3, ref readonly Vector3 value4, float amount, out Vector3 result)`

#### Parameters

`value1`

Vector3The first position in the interpolation.

`value2`

Vector3The second position in the interpolation.

`value3`

Vector3The third position in the interpolation.

`value4`

Vector3The fourth position in the interpolation.

`amount`

floatWeighting factor.

`result`

Vector3When the method completes, contains the result of the Catmull-Rom interpolation.

### Clamp(Vector3, Vector3, Vector3)

Restricts a value to be within a specified range.

`public static Vector3 Clamp(Vector3 value, Vector3 min, Vector3 max)`

#### Parameters

#### Returns

- Vector3
The clamped value.

### Clamp(ref readonly Vector3, ref readonly Vector3, ref readonly Vector3, out Vector3)

Restricts a value to be within a specified range.

`public static void Clamp(ref readonly Vector3 value, ref readonly Vector3 min, ref readonly Vector3 max, out Vector3 result)`

#### Parameters

`value`

Vector3The value to clamp.

`min`

Vector3The minimum value.

`max`

Vector3The maximum value.

`result`

Vector3When the method completes, contains the clamped value.

### Cross(in Vector3, in Vector3)

Calculates the cross product of two vectors.

`public static Vector3 Cross(in Vector3 left, in Vector3 right)`

#### Parameters

#### Returns

- Vector3
The cross product of the two vectors.

### Cross(ref readonly Vector3, ref readonly Vector3, out Vector3)

Calculates the cross product of two vectors.

`public static void Cross(ref readonly Vector3 left, ref readonly Vector3 right, out Vector3 result)`

#### Parameters

`left`

Vector3First source vector.

`right`

Vector3Second source vector.

`result`

Vector3When the method completes, contains he cross product of the two vectors.

### Deconstruct(out float, out float, out float)

Deconstructs the vector's components into named variables.

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

#### Parameters

### Demodulate(Vector3, Vector3)

Demodulates a vector with another by performing component-wise division.

`public static Vector3 Demodulate(Vector3 left, Vector3 right)`

#### Parameters

#### Returns

- Vector3
The demodulated vector.

### Demodulate(ref readonly Vector3, ref readonly Vector3, out Vector3)

Demodulates a vector with another by performing component-wise division.

`public static void Demodulate(ref readonly Vector3 left, ref readonly Vector3 right, out Vector3 result)`

#### Parameters

`left`

Vector3The first vector to demodulate.

`right`

Vector3The second vector to demodulate.

`result`

Vector3When the method completes, contains the demodulated vector.

### Distance(Vector3, Vector3)

Calculates the distance between two vectors.

`public static float Distance(Vector3 value1, Vector3 value2)`

#### Parameters

#### Returns

- float
The distance between the two vectors.

#### Remarks

DistanceSquared(Vector3, Vector3) may be preferred when only the relative distance is needed and speed is of the essence.

### Distance(ref readonly Vector3, ref readonly Vector3, out float)

Calculates the distance between two vectors.

`public static void Distance(ref readonly Vector3 value1, ref readonly Vector3 value2, out float result)`

#### Parameters

`value1`

Vector3The first vector.

`value2`

Vector3The second vector.

`result`

floatWhen the method completes, contains the distance between the two vectors.

#### Remarks

DistanceSquared(ref readonly Vector3, ref readonly Vector3, out float) may be preferred when only the relative distance is needed and speed is of the essence.

### DistanceSquared(Vector3, Vector3)

Calculates the squared distance between two vectors.

`public static float DistanceSquared(Vector3 value1, Vector3 value2)`

#### Parameters

#### Returns

- float
The squared distance between the two vectors.

#### Remarks

Distance squared is the value before taking the square root. Distance squared can often be used in place of distance if relative comparisons are being made. For example, consider three points A, B, and C. To determine whether B or C is further from A, compare the distance between A and B to the distance between A and C. Calculating the two distances involves two square roots, which are computationally expensive. However, using distance squared provides the same information and avoids calculating two square roots.

### DistanceSquared(ref readonly Vector3, ref readonly Vector3, out float)

Calculates the squared distance between two vectors.

`public static void DistanceSquared(ref readonly Vector3 value1, ref readonly Vector3 value2, out float result)`

#### Parameters

`value1`

Vector3The first vector.

`value2`

Vector3The second vector.

`result`

floatWhen the method completes, contains the squared distance between the two vectors.

#### Remarks

Distance squared is the value before taking the square root. Distance squared can often be used in place of distance if relative comparisons are being made. For example, consider three points A, B, and C. To determine whether B or C is further from A, compare the distance between A and B to the distance between A and C. Calculating the two distances involves two square roots, which are computationally expensive. However, using distance squared provides the same information and avoids calculating two square roots.

### Divide(Vector3, float)

Scales a vector by the given value.

`public static Vector3 Divide(Vector3 value, float scale)`

#### Parameters

#### Returns

- Vector3
The scaled vector.

### Divide(ref readonly Vector3, float, out Vector3)

Scales a vector by the given value.

`public static void Divide(ref readonly Vector3 value, float scale, out Vector3 result)`

#### Parameters

`value`

Vector3The vector to scale.

`scale`

floatThe amount by which to scale the vector.

`result`

Vector3When the method completes, contains the scaled vector.

### Dot(Vector3, Vector3)

Calculates the dot product of two vectors.

`public static float Dot(Vector3 left, Vector3 right)`

#### Parameters

#### Returns

- float
The dot product of the two vectors.

### Dot(ref readonly Vector3, ref readonly Vector3, out float)

Calculates the dot product of two vectors.

`public static void Dot(ref readonly Vector3 left, ref readonly Vector3 right, out float result)`

#### Parameters

`left`

Vector3First source vector.

`right`

Vector3Second source vector.

`result`

floatWhen the method completes, contains the dot product of the two vectors.

### Equals(Vector3)

Determines whether the specified Vector3 is equal to this instance.

`public bool Equals(Vector3 other)`

#### Parameters

#### Returns

### Equals(object)

Determines whether the specified object is equal to this instance.

`public override bool Equals(object value)`

#### Parameters

#### Returns

### GetHashCode()

Returns a hash code for this instance.

`public override int GetHashCode()`

#### Returns

- int
A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table.

### Hermite(Vector3, Vector3, Vector3, Vector3, float)

Performs a Hermite spline interpolation.

`public static Vector3 Hermite(Vector3 value1, Vector3 tangent1, Vector3 value2, Vector3 tangent2, float amount)`

#### Parameters

`value1`

Vector3First source position vector.

`tangent1`

Vector3First source tangent vector.

`value2`

Vector3Second source position vector.

`tangent2`

Vector3Second source tangent vector.

`amount`

floatWeighting factor.

#### Returns

- Vector3
The result of the Hermite spline interpolation.

### Hermite(ref readonly Vector3, ref readonly Vector3, ref readonly Vector3, ref readonly Vector3, float, out Vector3)

Performs a Hermite spline interpolation.

`public static void Hermite(ref readonly Vector3 value1, ref readonly Vector3 tangent1, ref readonly Vector3 value2, ref readonly Vector3 tangent2, float amount, out Vector3 result)`

#### Parameters

`value1`

Vector3First source position vector.

`tangent1`

Vector3First source tangent vector.

`value2`

Vector3Second source position vector.

`tangent2`

Vector3Second source tangent vector.

`amount`

floatWeighting factor.

`result`

Vector3When the method completes, contains the result of the Hermite spline interpolation.

### Length()

Calculates the length of the vector.

`public readonly float Length()`

#### Returns

- float
The length of the vector.

#### Remarks

LengthSquared() may be preferred when only the relative length is needed and speed is of the essence.

### LengthSquared()

Calculates the squared length of the vector.

`public readonly float LengthSquared()`

#### Returns

- float
The squared length of the vector.

#### Remarks

This method may be preferred to Length() when only a relative length is needed and speed is of the essence.

### Lerp(Vector3, Vector3, float)

Performs a linear interpolation between two vectors.

`public static Vector3 Lerp(Vector3 start, Vector3 end, float amount)`

#### Parameters

`start`

Vector3Start vector.

`end`

Vector3End vector.

`amount`

floatValue between 0 and 1 indicating the weight of

`end`

.

#### Returns

- Vector3
The linear interpolation of the two vectors.

#### Remarks

This method performs the linear interpolation based on the following formula.

`start + (end - start) * amount`

Passing `amount`

a value of 0 will cause `start`

to be returned; a value of 1 will cause `end`

to be returned.

### Lerp(ref readonly Vector3, ref readonly Vector3, float, out Vector3)

Performs a linear interpolation between two vectors.

`public static void Lerp(ref readonly Vector3 start, ref readonly Vector3 end, float amount, out Vector3 result)`

#### Parameters

`start`

Vector3Start vector.

`end`

Vector3End vector.

`amount`

floatValue between 0 and 1 indicating the weight of

`end`

.`result`

Vector3When the method completes, contains the linear interpolation of the two vectors.

#### Remarks

This method performs the linear interpolation based on the following formula.

`start + (end - start) * amount`

Passing `amount`

a value of 0 will cause `start`

to be returned; a value of 1 will cause `end`

to be returned.

### Max(Vector3, Vector3)

Returns a vector containing the largest components of the specified vectors.

`public static Vector3 Max(Vector3 left, Vector3 right)`

#### Parameters

#### Returns

- Vector3
A vector containing the largest components of the source vectors.

### Max(ref readonly Vector3, ref readonly Vector3, out Vector3)

Returns a vector containing the largest components of the specified vectors.

`public static void Max(ref readonly Vector3 left, ref readonly Vector3 right, out Vector3 result)`

#### Parameters

`left`

Vector3The first source vector.

`right`

Vector3The second source vector.

`result`

Vector3When the method completes, contains an new vector composed of the largest components of the source vectors.

### Min(Vector3, Vector3)

Returns a vector containing the smallest components of the specified vectors.

`public static Vector3 Min(Vector3 left, Vector3 right)`

#### Parameters

#### Returns

- Vector3
A vector containing the smallest components of the source vectors.

### Min(ref readonly Vector3, ref readonly Vector3, out Vector3)

Returns a vector containing the smallest components of the specified vectors.

`public static void Min(ref readonly Vector3 left, ref readonly Vector3 right, out Vector3 result)`

#### Parameters

`left`

Vector3The first source vector.

`right`

Vector3The second source vector.

`result`

Vector3When the method completes, contains an new vector composed of the smallest components of the source vectors.

### Mod(Vector3, Vector3)

Performs mathematical modulo component-wise (see MathUtil.Mod).

`public static Vector3 Mod(Vector3 left, Vector3 right)`

#### Parameters

#### Returns

- Vector3
When the method completes, contains an new vector composed of each component's modulo.

### Mod(ref readonly Vector3, ref readonly Vector3, out Vector3)

Performs mathematical modulo component-wise (see MathUtil.Mod).

`public static void Mod(ref readonly Vector3 left, ref readonly Vector3 right, out Vector3 result)`

#### Parameters

`left`

Vector3The first source vector.

`right`

Vector3The second source vector.

`result`

Vector3When the method completes, contains an new vector composed of each component's modulo.

### Modulate(Vector3, Vector3)

Modulates a vector with another by performing component-wise multiplication.

`public static Vector3 Modulate(Vector3 left, Vector3 right)`

#### Parameters

#### Returns

- Vector3
The modulated vector.

### Modulate(ref readonly Vector3, ref readonly Vector3, out Vector3)

Modulates a vector with another by performing component-wise multiplication.

`public static void Modulate(ref readonly Vector3 left, ref readonly Vector3 right, out Vector3 result)`

#### Parameters

`left`

Vector3The first vector to modulate.

`right`

Vector3The second vector to modulate.

`result`

Vector3When the method completes, contains the modulated vector.

### MoveTo(in Vector3, in Vector3, float)

Moves the first vector3 to the second one in a straight line.

`public static Vector3 MoveTo(in Vector3 from, in Vector3 to, float maxTravelDistance)`

#### Parameters

`from`

Vector3The first point.

`to`

Vector3The second point.

`maxTravelDistance`

floatThe rate at which the first point is going to move towards the second point.

#### Returns

### Multiply(Vector3, float)

Scales a vector by the given value.

`public static Vector3 Multiply(Vector3 value, float scale)`

#### Parameters

#### Returns

- Vector3
The scaled vector.

### Multiply(ref readonly Vector3, float, out Vector3)

Scales a vector by the given value.

`public static void Multiply(ref readonly Vector3 value, float scale, out Vector3 result)`

#### Parameters

`value`

Vector3The vector to scale.

`scale`

floatThe amount by which to scale the vector.

`result`

Vector3When the method completes, contains the scaled vector.

### NearEqual(ref readonly Vector3, ref readonly Vector3, ref readonly Vector3)

Tests whether one 3D vector is near another 3D vector.

`public static bool NearEqual(ref readonly Vector3 left, ref readonly Vector3 right, ref readonly Vector3 epsilon)`

#### Parameters

#### Returns

- bool
`true`

if left and right are near another 3D,`false`

otherwise

### Negate(Vector3)

Reverses the direction of a given vector.

`public static Vector3 Negate(Vector3 value)`

#### Parameters

`value`

Vector3The vector to negate.

#### Returns

- Vector3
A vector facing in the opposite direction.

### Negate(ref readonly Vector3, out Vector3)

Reverses the direction of a given vector.

`public static void Negate(ref readonly Vector3 value, out Vector3 result)`

#### Parameters

`value`

Vector3The vector to negate.

`result`

Vector3When the method completes, contains a vector facing in the opposite direction.

### Normalize()

Converts the vector into a unit vector.

`public void Normalize()`

### Normalize(Vector3)

Converts the vector into a unit vector.

`public static Vector3 Normalize(Vector3 value)`

#### Parameters

`value`

Vector3The vector to normalize.

#### Returns

- Vector3
The normalized vector.

### Normalize(ref readonly Vector3, out Vector3)

Converts the vector into a unit vector.

`public static void Normalize(ref readonly Vector3 value, out Vector3 result)`

#### Parameters

`value`

Vector3The vector to normalize.

`result`

Vector3When the method completes, contains the normalized vector.

### Orthogonalize(Vector3[], params Vector3[])

Orthogonalizes a list of vectors.

`public static void Orthogonalize(Vector3[] destination, params Vector3[] source)`

#### Parameters

`destination`

Vector3[]The list of orthogonalized vectors.

`source`

Vector3[]The list of vectors to orthogonalize.

#### Remarks

Orthogonalization is the process of making all vectors orthogonal to each other. This means that any given vector in the list will be orthogonal to any other given vector in the list.

Because this method uses the modified Gram-Schmidt process, the resulting vectors tend to be numerically unstable. The numeric stability decreases according to the vectors position in the list so that the first vector is the most stable and the last vector is the least stable.

#### Exceptions

- ArgumentNullException
Thrown when

`source`

or`destination`

is`null`

.- ArgumentOutOfRangeException
Thrown when

`destination`

is shorter in length than`source`

.

### Orthonormalize(Vector3[], params Vector3[])

Orthonormalizes a list of vectors.

`public static void Orthonormalize(Vector3[] destination, params Vector3[] source)`

#### Parameters

`destination`

Vector3[]The list of orthonormalized vectors.

`source`

Vector3[]The list of vectors to orthonormalize.

#### Remarks

Orthonormalization is the process of making all vectors orthogonal to each other and making all vectors of unit length. This means that any given vector will be orthogonal to any other given vector in the list.

Because this method uses the modified Gram-Schmidt process, the resulting vectors tend to be numerically unstable. The numeric stability decreases according to the vectors position in the list so that the first vector is the most stable and the last vector is the least stable.

#### Exceptions

- ArgumentNullException
Thrown when

`source`

or`destination`

is`null`

.- ArgumentOutOfRangeException
Thrown when

`destination`

is shorter in length than`source`

.

### Pow(float)

Raises the exponent for each components.

`public void Pow(float exponent)`

#### Parameters

`exponent`

floatThe exponent.

### Project(Vector3, float, float, float, float, float, float, Matrix)

Projects a 3D vector from object space into screen space.

`public static Vector3 Project(Vector3 vector, float x, float y, float width, float height, float minZ, float maxZ, Matrix worldViewProjection)`

#### Parameters

`vector`

Vector3The vector to project.

`x`

floatThe X position of the viewport.

`y`

floatThe Y position of the viewport.

`width`

floatThe width of the viewport.

`height`

floatThe height of the viewport.

`minZ`

floatThe minimum depth of the viewport.

`maxZ`

floatThe maximum depth of the viewport.

`worldViewProjection`

MatrixThe combined world-view-projection matrix.

#### Returns

- Vector3
The vector in screen space.

### Project(ref readonly Vector3, float, float, float, float, float, float, ref readonly Matrix, out Vector3)

Projects a 3D vector from object space into screen space.

`public static void Project(ref readonly Vector3 vector, float x, float y, float width, float height, float minZ, float maxZ, ref readonly Matrix worldViewProjection, out Vector3 result)`

#### Parameters

`vector`

Vector3The vector to project.

`x`

floatThe X position of the viewport.

`y`

floatThe Y position of the viewport.

`width`

floatThe width of the viewport.

`height`

floatThe height of the viewport.

`minZ`

floatThe minimum depth of the viewport.

`maxZ`

floatThe maximum depth of the viewport.

`worldViewProjection`

MatrixThe combined world-view-projection matrix.

`result`

Vector3When the method completes, contains the vector in screen space.

### Reflect(Vector3, Vector3)

Returns the reflection of a vector off a surface that has the specified normal.

`public static Vector3 Reflect(Vector3 vector, Vector3 normal)`

#### Parameters

#### Returns

- Vector3
The reflected vector.

#### Remarks

Reflect only gives the direction of a reflection off a surface, it does not determine whether the original vector was close enough to the surface to hit it.

### Reflect(ref readonly Vector3, ref readonly Vector3, out Vector3)

Returns the reflection of a vector off a surface that has the specified normal.

`public static void Reflect(ref readonly Vector3 vector, ref readonly Vector3 normal, out Vector3 result)`

#### Parameters

`vector`

Vector3The source vector.

`normal`

Vector3Normal of the surface.

`result`

Vector3When the method completes, contains the reflected vector.

#### Remarks

Reflect only gives the direction of a reflection off a surface, it does not determine whether the original vector was close enough to the surface to hit it.

### RotateAround(in Vector3, in Vector3, in Vector3, float)

Rotates the source around the target by the rotation angle around the supplied axis.

`public static Vector3 RotateAround(in Vector3 source, in Vector3 target, in Vector3 axis, float angle)`

#### Parameters

`source`

Vector3The position to rotate.

`target`

Vector3The point to rotate around.

`axis`

Vector3The axis of rotation.

`angle`

floatThe angle to rotate by in radians.

#### Returns

- Vector3
The rotated vector.

### RotationYawPitchRoll(Quaternion)

Calculate the yaw/pitch/roll rotation equivalent to the provided quaterion.

`public static Vector3 RotationYawPitchRoll(Quaternion quaternion)`

#### Parameters

`quaternion`

QuaternionThe input rotation as quaternion

#### Returns

- Vector3
The equivation yaw/pitch/roll rotation

### RotationYawPitchRoll(ref readonly Quaternion, out Vector3)

Calculate the yaw/pitch/roll rotation equivalent to the provided quaterion.

`public static void RotationYawPitchRoll(ref readonly Quaternion quaternion, out Vector3 yawPitchRoll)`

#### Parameters

`quaternion`

QuaternionThe input rotation as quaternion

`yawPitchRoll`

Vector3The equivation yaw/pitch/roll rotation

### SmoothStep(Vector3, Vector3, float)

Performs a cubic interpolation between two vectors.

`public static Vector3 SmoothStep(Vector3 start, Vector3 end, float amount)`

#### Parameters

`start`

Vector3Start vector.

`end`

Vector3End vector.

`amount`

floatValue between 0 and 1 indicating the weight of

`end`

.

#### Returns

- Vector3
The cubic interpolation of the two vectors.

### SmoothStep(ref readonly Vector3, ref readonly Vector3, float, out Vector3)

Performs a cubic interpolation between two vectors.

`public static void SmoothStep(ref readonly Vector3 start, ref readonly Vector3 end, float amount, out Vector3 result)`

#### Parameters

`start`

Vector3Start vector.

`end`

Vector3End vector.

`amount`

floatValue between 0 and 1 indicating the weight of

`end`

.`result`

Vector3When the method completes, contains the cubic interpolation of the two vectors.

### Subtract(in Vector3, in Vector3)

Subtracts two vectors.

`public static Vector3 Subtract(in Vector3 left, in Vector3 right)`

#### Parameters

#### Returns

- Vector3
The difference of the two vectors.

### Subtract(ref readonly Vector3, ref readonly Vector3, out Vector3)

Subtracts two vectors.

`public static void Subtract(ref readonly Vector3 left, ref readonly Vector3 right, out Vector3 result)`

#### Parameters

`left`

Vector3The first vector to subtract.

`right`

Vector3The second vector to subtract.

`result`

Vector3When the method completes, contains the difference of the two vectors.

### ToArray()

Creates an array containing the elements of the vector.

`public float[] ToArray()`

#### Returns

- float[]
A three-element array containing the components of the vector.

### ToString()

Returns a string that represents this instance.

`public override string ToString()`

#### Returns

### ToString(IFormatProvider)

Returns a string that represents this instance.

`public string ToString(IFormatProvider formatProvider)`

#### Parameters

`formatProvider`

IFormatProviderThe format provider.

#### Returns

### ToString(string)

Returns a string that represents this instance.

`public string ToString(string format)`

#### Parameters

`format`

stringThe format.

#### Returns

### ToString(string, IFormatProvider)

Returns a string that represents this instance.

`public string ToString(string format, IFormatProvider formatProvider)`

#### Parameters

`format`

stringThe format.

`formatProvider`

IFormatProviderThe format provider.

#### Returns

### Transform(Vector3, Matrix)

Transforms a 3D vector by the given Matrix.

`public static Vector4 Transform(Vector3 vector, Matrix transform)`

#### Parameters

#### Returns

### Transform(Vector3, Quaternion)

Transforms a 3D vector by the given Quaternion rotation.

`public static Vector3 Transform(Vector3 vector, Quaternion rotation)`

#### Parameters

`vector`

Vector3The vector to rotate.

`rotation`

QuaternionThe Quaternion rotation to apply.

#### Returns

### Transform(ref readonly Vector3, ref readonly Matrix, out Vector3)

Transforms a 3D vector by the given Matrix.

`public static void Transform(ref readonly Vector3 vector, ref readonly Matrix transform, out Vector3 result)`

#### Parameters

`vector`

Vector3The source vector.

`transform`

MatrixThe transformation Matrix.

`result`

Vector3When the method completes, contains the transformed Vector3.

### Transform(ref readonly Vector3, ref readonly Matrix, out Vector4)

Transforms a 3D vector by the given Matrix.

`public static void Transform(ref readonly Vector3 vector, ref readonly Matrix transform, out Vector4 result)`

#### Parameters

`vector`

Vector3The source vector.

`transform`

MatrixThe transformation Matrix.

`result`

Vector4When the method completes, contains the transformed Vector4.

### Transform(ref readonly Vector3, ref readonly Quaternion, out Vector3)

Transforms a 3D vector by the given Quaternion rotation.

`public static void Transform(ref readonly Vector3 vector, ref readonly Quaternion rotation, out Vector3 result)`

#### Parameters

`vector`

Vector3The vector to rotate.

`rotation`

QuaternionThe Quaternion rotation to apply.

`result`

Vector3When the method completes, contains the transformed Vector4.

### Transform(Vector3[], ref readonly Matrix, Vector4[])

Transforms an array of 3D vectors by the given Matrix.

`public static void Transform(Vector3[] source, ref readonly Matrix transform, Vector4[] destination)`

#### Parameters

`source`

Vector3[]The array of vectors to transform.

`transform`

MatrixThe transformation Matrix.

`destination`

Vector4[]The array for which the transformed vectors are stored.

#### Exceptions

- ArgumentNullException
Thrown when

`source`

or`destination`

is`null`

.- ArgumentOutOfRangeException
Thrown when

`destination`

is shorter in length than`source`

.

### Transform(Vector3[], ref readonly Quaternion, Vector3[])

Transforms an array of vectors by the given Quaternion rotation.

`public static void Transform(Vector3[] source, ref readonly Quaternion rotation, Vector3[] destination)`

#### Parameters

`source`

Vector3[]The array of vectors to transform.

`rotation`

QuaternionThe Quaternion rotation to apply.

`destination`

Vector3[]The array for which the transformed vectors are stored. This array may be the same array as

`source`

.

#### Exceptions

- ArgumentNullException
Thrown when

`source`

or`destination`

is`null`

.- ArgumentOutOfRangeException
Thrown when

`destination`

is shorter in length than`source`

.

### TransformCoordinate(Vector3, Matrix)

Performs a coordinate transformation using the given Matrix.

`public static Vector3 TransformCoordinate(Vector3 coordinate, Matrix transform)`

#### Parameters

#### Returns

- Vector3
The transformed coordinates.

#### Remarks

A coordinate transform performs the transformation with the assumption that the w component is one. The four dimensional vector obtained from the transformation operation has each component in the vector divided by the w component. This forces the wcomponent to be one and therefore makes the vector homogeneous. The homogeneous vector is often prefered when working with coordinates as the w component can safely be ignored.

### TransformCoordinate(ref readonly Vector3, ref readonly Matrix, out Vector3)

Performs a coordinate transformation using the given Matrix.

`public static void TransformCoordinate(ref readonly Vector3 coordinate, ref readonly Matrix transform, out Vector3 result)`

#### Parameters

`coordinate`

Vector3The coordinate vector to transform.

`transform`

MatrixThe transformation Matrix.

`result`

Vector3When the method completes, contains the transformed coordinates.

#### Remarks

A coordinate transform performs the transformation with the assumption that the w component is one. The four dimensional vector obtained from the transformation operation has each component in the vector divided by the w component. This forces the wcomponent to be one and therefore makes the vector homogeneous. The homogeneous vector is often prefered when working with coordinates as the w component can safely be ignored.

### TransformCoordinate(Vector3[], ref readonly Matrix, Vector3[])

Performs a coordinate transformation on an array of vectors using the given Matrix.

`public static void TransformCoordinate(Vector3[] source, ref readonly Matrix transform, Vector3[] destination)`

#### Parameters

`source`

Vector3[]The array of coordinate vectors to trasnform.

`transform`

MatrixThe transformation Matrix.

`destination`

Vector3[]The array for which the transformed vectors are stored. This array may be the same array as

`source`

.

#### Remarks

A coordinate transform performs the transformation with the assumption that the w component is one. The four dimensional vector obtained from the transformation operation has each component in the vector divided by the w component. This forces the wcomponent to be one and therefore makes the vector homogeneous. The homogeneous vector is often prefered when working with coordinates as the w component can safely be ignored.

#### Exceptions

- ArgumentNullException
Thrown when

`source`

or`destination`

is`null`

.- ArgumentOutOfRangeException
Thrown when

`destination`

is shorter in length than`source`

.

### TransformNormal(Vector3, Matrix)

Performs a normal transformation using the given Matrix.

`public static Vector3 TransformNormal(Vector3 normal, Matrix transform)`

#### Parameters

#### Returns

- Vector3
The transformed normal.

#### Remarks

A normal transform performs the transformation with the assumption that the w component is zero. This causes the fourth row and fourth collumn of the matrix to be unused. The end result is a vector that is not translated, but all other transformation properties apply. This is often prefered for normal vectors as normals purely represent direction rather than location because normal vectors should not be translated.

### TransformNormal(ref readonly Vector3, ref readonly Matrix, out Vector3)

Performs a normal transformation using the given Matrix.

`public static void TransformNormal(ref readonly Vector3 normal, ref readonly Matrix transform, out Vector3 result)`

#### Parameters

`normal`

Vector3The normal vector to transform.

`transform`

MatrixThe transformation Matrix.

`result`

Vector3When the method completes, contains the transformed normal.

#### Remarks

A normal transform performs the transformation with the assumption that the w component is zero. This causes the fourth row and fourth collumn of the matrix to be unused. The end result is a vector that is not translated, but all other transformation properties apply. This is often prefered for normal vectors as normals purely represent direction rather than location because normal vectors should not be translated.

### TransformNormal(Vector3[], ref readonly Matrix, Vector3[])

Performs a normal transformation on an array of vectors using the given Matrix.

`public static void TransformNormal(Vector3[] source, ref readonly Matrix transform, Vector3[] destination)`

#### Parameters

`source`

Vector3[]The array of normal vectors to transform.

`transform`

MatrixThe transformation Matrix.

`destination`

Vector3[]The array for which the transformed vectors are stored. This array may be the same array as

`source`

.

#### Remarks

A normal transform performs the transformation with the assumption that the w component is zero. This causes the fourth row and fourth collumn of the matrix to be unused. The end result is a vector that is not translated, but all other transformation properties apply. This is often prefered for normal vectors as normals purely represent direction rather than location because normal vectors should not be translated.

#### Exceptions

- ArgumentNullException
Thrown when

`source`

or`destination`

is`null`

.- ArgumentOutOfRangeException
Thrown when

`destination`

is shorter in length than`source`

.

### Unproject(Vector3, float, float, float, float, float, float, Matrix)

Projects a 3D vector from screen space into object space.

`public static Vector3 Unproject(Vector3 vector, float x, float y, float width, float height, float minZ, float maxZ, Matrix worldViewProjection)`

#### Parameters

`vector`

Vector3The vector to project.

`x`

floatThe X position of the viewport.

`y`

floatThe Y position of the viewport.

`width`

floatThe width of the viewport.

`height`

floatThe height of the viewport.

`minZ`

floatThe minimum depth of the viewport.

`maxZ`

floatThe maximum depth of the viewport.

`worldViewProjection`

MatrixThe combined world-view-projection matrix.

#### Returns

- Vector3
The vector in object space.

### Unproject(ref readonly Vector3, float, float, float, float, float, float, ref readonly Matrix, out Vector3)

Projects a 3D vector from screen space into object space.

`public static void Unproject(ref readonly Vector3 vector, float x, float y, float width, float height, float minZ, float maxZ, ref readonly Matrix worldViewProjection, out Vector3 result)`

#### Parameters

`vector`

Vector3The vector to project.

`x`

floatThe X position of the viewport.

`y`

floatThe Y position of the viewport.

`width`

floatThe width of the viewport.

`height`

floatThe height of the viewport.

`minZ`

floatThe minimum depth of the viewport.

`maxZ`

floatThe maximum depth of the viewport.

`worldViewProjection`

MatrixThe combined world-view-projection matrix.

`result`

Vector3When the method completes, contains the vector in object space.

## Operators

### operator +(in Vector3, in Vector3)

Adds two vectors.

`public static Vector3 operator +(in Vector3 left, in Vector3 right)`

#### Parameters

#### Returns

- Vector3
The sum of the two vectors.

### operator +(in Vector3, float)

Adds a vector with the given value.

`public static Vector3 operator +(in Vector3 value, float scale)`

#### Parameters

#### Returns

- Vector3
The vector offset.

### operator /(in Vector3, in Vector3)

Divides a vector by the given vector, component-wise.

`public static Vector3 operator /(in Vector3 value, in Vector3 by)`

#### Parameters

#### Returns

- Vector3
The scaled vector.

### operator /(in Vector3, float)

Scales a vector by the given value.

`public static Vector3 operator /(in Vector3 value, float scale)`

#### Parameters

#### Returns

- Vector3
The scaled vector.

### operator /(float, in Vector3)

Divides a numerator by a vector.

`public static Vector3 operator /(float numerator, in Vector3 value)`

#### Parameters

#### Returns

- Vector3
The scaled vector.

### operator ==(Vector3, Vector3)

Tests for equality between two objects.

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

#### Parameters

#### Returns

- bool
`true`

if`left`

has the same value as`right`

; otherwise,`false`

.

### explicit operator Int3(in Vector3)

`public static explicit operator Int3(in Vector3 value)`

#### Parameters

`value`

Vector3The value.

#### Returns

- Int3
The result of the conversion.

### explicit operator Vector2(in Vector3)

`public static explicit operator Vector2(in Vector3 value)`

#### Parameters

`value`

Vector3The value.

#### Returns

- Vector2
The result of the conversion.

### explicit operator Vector4(in Vector3)

`public static explicit operator Vector4(in Vector3 value)`

#### Parameters

`value`

Vector3The value.

#### Returns

- Vector4
The result of the conversion.

### operator !=(Vector3, Vector3)

Tests for inequality between two objects.

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

#### Parameters

#### Returns

- bool
`true`

if`left`

has a different value than`right`

; otherwise,`false`

.

### operator *(in Vector3, in Vector3)

Modulates a vector with another by performing component-wise multiplication.

`public static Vector3 operator *(in Vector3 left, in Vector3 right)`

#### Parameters

#### Returns

- Vector3
The multiplication of the two vectors.

### operator *(in Vector3, float)

Scales a vector by the given value.

`public static Vector3 operator *(in Vector3 value, float scale)`

#### Parameters

#### Returns

- Vector3
The scaled vector.

### operator *(float, in Vector3)

Scales a vector by the given value.

`public static Vector3 operator *(float scale, in Vector3 value)`

#### Parameters

#### Returns

- Vector3
The scaled vector.

### operator -(in Vector3, in Vector3)

Subtracts two vectors.

`public static Vector3 operator -(in Vector3 left, in Vector3 right)`

#### Parameters

#### Returns

- Vector3
The difference of the two vectors.

### operator -(in Vector3, float)

Substracts a vector by the given value.

`public static Vector3 operator -(in Vector3 value, float scale)`

#### Parameters

#### Returns

- Vector3
The vector offset.

### operator -(in Vector3)

Reverses the direction of a given vector.

`public static Vector3 operator -(in Vector3 value)`

#### Parameters

`value`

Vector3The vector to negate.

#### Returns

- Vector3
A vector facing in the opposite direction.

### operator +(in Vector3)

Assert a vector (return it unchanged).

`public static Vector3 operator +(in Vector3 value)`

#### Parameters

`value`

Vector3The vector to assert (unchange).

#### Returns

- Vector3
The asserted (unchanged) vector.