Vector3 Struct Reference

vector of 3 floats More...

List of all members.

Public Member Functions
	Vector3 (float x, float y, float z)
	constructor taking three floats
	Vector3 (Vector2 xy, float z)
	constructor taking a Vector2 and a float
	Vector3 (float f)
	constructor taking one float
float	Length ()
	return the length of this vector
float	LengthSquared ()
	return the length squared of this vector
float	Distance (Vector3 v)
	get the distance between this and another vector
float	Distance (ref Vector3 v)
	get the distance between this and another vector
float	DistanceSquared (Vector3 v)
	get the distance squared between this and another vector
float	DistanceSquared (ref Vector3 v)
	get the distance squared between this and another vector
float	Dot (Vector3 v)
	dot product of this and v
float	Dot (ref Vector3 v)
	dot product of this and v
Vector3	Cross (Vector3 v)
	cross product
void	Cross (ref Vector3 v, out Vector3 result)
	cross product
Vector3	Normalize ()
	return this vector normalized
void	Normalize (out Vector3 result)
	return this vector normalized
Vector3	Abs ()
	element wise absolute value
void	Abs (out Vector3 result)
	element wise absolute value
Vector3	Min (Vector3 v)
	element wise min
void	Min (ref Vector3 v, out Vector3 result)
	element wise min
Vector3	Min (float f)
	element wise min
void	Min (float f, out Vector3 result)
	element wise min
Vector3	Max (Vector3 v)
	element wise max
void	Max (ref Vector3 v, out Vector3 result)
	element wise max
Vector3	Max (float f)
	element wise max
void	Max (float f, out Vector3 result)
	element wise max
Vector3	Clamp (Vector3 min, Vector3 max)
	element wise clamp
void	Clamp (ref Vector3 min, ref Vector3 max, out Vector3 result)
	element wise clamp
Vector3	Clamp (float min, float max)
	element wise clamp
void	Clamp (float min, float max, out Vector3 result)
	element wise clamp
Vector3	Repeat (Vector3 min, Vector3 max)
	element wise repeat
void	Repeat (ref Vector3 min, ref Vector3 max, out Vector3 result)
	element wise repeat
Vector3	Repeat (float min, float max)
	element wise repeat
void	Repeat (float min, float max, out Vector3 result)
	element wise repeat
Vector3	Lerp (Vector3 v, float f)
	lerp between this and the other vector
void	Lerp (ref Vector3 v, float f, out Vector3 result)
	lerp between this and the other vector
Vector3	Slerp (Vector3 v, float f)
	slerp between this and the other vector
void	Slerp (ref Vector3 v, float f, out Vector3 result)
	slerp between this and the other vector
Vector3	MoveTo (Vector3 v, float length)
	move to target vector by specified length
void	MoveTo (ref Vector3 v, float length, out Vector3 result)
	move to target vector by specified length
Vector3	TurnTo (Vector3 v, float angle)
	turn to target vector by specified angle
void	TurnTo (ref Vector3 v, float angle, out Vector3 result)
	turn to target vector by specified angle
float	Angle (Vector3 v)
	get the angle between this and the input vector
float	Angle (ref Vector3 v)
	get the angle between this and the input vector
Vector3	RotateX (float angle)
	rotate this around the x axis by an angle
void	RotateX (float angle, out Vector3 result)
	rotate this around the x axis by an angle
Vector3	RotateX (Vector2 rotation)
	rotate this around the x axis by an angle
void	RotateX (ref Vector2 rotation, out Vector3 result)
	rotate this around the x axis by an angle
Vector3	RotateY (float angle)
	rotate this around the y axis by an angle
void	RotateY (float angle, out Vector3 result)
	rotate this around the y axis by an angle
Vector3	RotateY (Vector2 rotation)
	rotate this around the y axis by an angle
void	RotateY (ref Vector2 rotation, out Vector3 result)
	rotate this around the y axis by an angle
Vector3	RotateZ (float angle)
	rotate this around the z axis by an angle
void	RotateZ (float angle, out Vector3 result)
	rotate this around the z axis by an angle
Vector3	RotateZ (Vector2 rotation)
	rotate this around the z axis by an angle
void	RotateZ (ref Vector2 rotation, out Vector3 result)
	rotate this around the z axis by an angle
Vector3	Reflect (Vector3 normal)
	return this vector reflected about normal
void	Reflect (ref Vector3 normal, out Vector3 result)
	return this vector reflected about normal
Vector3	Perpendicular ()
	return a vector perpendicular to this
void	Perpendicular (out Vector3 result)
	return a vector perpendicular to this
Vector3	ProjectOnLine (Vector3 point, Vector3 direction)
	project this vector onto the line (point,direction)
void	ProjectOnLine (ref Vector3 point, ref Vector3 direction, out Vector3 result)
	project this vector onto the line (point,direction)
Vector3	Add (Vector3 v)
	return this + v
void	Add (ref Vector3 v, out Vector3 result)
	result = this + v
Vector3	Subtract (Vector3 v)
	return this - v
void	Subtract (ref Vector3 v, out Vector3 result)
	result = this - v
Vector3	Multiply (Vector3 v)
	return this * v
void	Multiply (ref Vector3 v, out Vector3 result)
	result = this * v
Vector3	Multiply (float f)
	return this * f
void	Multiply (float f, out Vector3 result)
	result = this * f
Vector3	Divide (Vector3 v)
	return this / v
void	Divide (ref Vector3 v, out Vector3 result)
	result = this / v
Vector3	Divide (float f)
	return this / f
void	Divide (float f, out Vector3 result)
	result = this / f
Vector3	Negate ()
	return -this
void	Negate (out Vector3 result)
	result = -this
bool	IsUnit (float epsilon)
	unit vector test
bool	IsZero ()
	test if all elements of this are zero
bool	IsOne ()
	test if all elements of this are one
bool	IsInfinity ()
	test if any elements of this are Infinity
bool	IsNaN ()
	test if any elements of this are NaN
bool	Equals (Vector3 v, float epsilon)
	equality test with an epsilon
bool	Equals (Vector3 v)
	equality test
override bool	Equals (Object o)
	equality test
override string	ToString ()
	return the string representation of this
override int	GetHashCode ()
	gets the hash code for this vector
Static Public Member Functions
static float	Length (Vector3 v)
	static function equivalent to Length()
static float	Length (ref Vector3 v)
	static function equivalent to Length()
static float	LengthSquared (Vector3 v)
	static function equivalent to LengthSquared()
static float	LengthSquared (ref Vector3 v)
	static function equivalent to LengthSquared()
static float	Distance (Vector3 v1, Vector3 v2)
	static function equivalent to Distance(Vector3)
static float	Distance (ref Vector3 v1, ref Vector3 v2)
	static function equivalent to Distance(ref Vector3)
static float	DistanceSquared (Vector3 v1, Vector3 v2)
	static function equivalent to DistanceSquared(Vector3)
static float	DistanceSquared (ref Vector3 v1, ref Vector3 v2)
	static function equivalent to DistanceSquared(ref Vector3)
static float	Dot (Vector3 v1, Vector3 v2)
	static function equivalent to Dot(Vector3)
static float	Dot (ref Vector3 v1, ref Vector3 v2)
	static function equivalent to Dot(ref Vector3)
static Vector3	Cross (Vector3 v1, Vector3 v2)
	static function equivalent to Cross(Vector3)
static void	Cross (ref Vector3 v1, ref Vector3 v2, out Vector3 result)
	static function equivalent to Cross(ref Vector3, out Vector3)
static Vector3	Normalize (Vector3 v)
	static function equivalent to Normalize()
static void	Normalize (ref Vector3 v, out Vector3 result)
	static function equivalent to Normalize(out Vector3)
static Vector3	Abs (Vector3 v)
	static function equivalent to Abs()
static void	Abs (ref Vector3 v, out Vector3 result)
	static function equivalent to Abs(out Vector3)
static Vector3	Min (Vector3 v1, Vector3 v2)
	static function equivalent to Min(Vector3)
static void	Min (ref Vector3 v1, ref Vector3 v2, out Vector3 result)
	static function equivalent to Min(ref Vector3, out Vector3)
static Vector3	Min (Vector3 v, float f)
	static function equivalent to Min(float)
static void	Min (ref Vector3 v, float f, out Vector3 result)
	static function equivalent to Min(float, out Vector3)
static Vector3	Max (Vector3 v1, Vector3 v2)
	static function equivalent to Max(Vector3)
static void	Max (ref Vector3 v1, ref Vector3 v2, out Vector3 result)
	static function equivalent to Max(ref Vector3, out Vector3)
static Vector3	Max (Vector3 v, float f)
	static function equivalent to Max(float)
static void	Max (ref Vector3 v, float f, out Vector3 result)
	static function equivalent to Max(float, out Vector3)
static Vector3	Clamp (Vector3 v, Vector3 min, Vector3 max)
	static function equivalent to Clamp(Vector3, Vector3)
static void	Clamp (ref Vector3 v, ref Vector3 min, ref Vector3 max, out Vector3 result)
	static function equivalent to Clamp(ref Vector3, ref Vector3, out Vector3)
static Vector3	Clamp (Vector3 v, float min, float max)
	static function equivalent to Clamp(float, float)
static void	Clamp (ref Vector3 v, float min, float max, out Vector3 result)
	static function equivalent to Clamp(float, float, out Vector3)
static Vector3	Repeat (Vector3 v, Vector3 min, Vector3 max)
	static function equivalent to Repeat(Vector3, Vector3)
static void	Repeat (ref Vector3 v, ref Vector3 min, ref Vector3 max, out Vector3 result)
	static function equivalent to Repeat(ref Vector3, ref Vector3, out Vector3)
static Vector3	Repeat (Vector3 v, float min, float max)
	static function equivalent to Repeat(float, float)
static void	Repeat (ref Vector3 v, float min, float max, out Vector3 result)
	static function equivalent to Repeat(float, float, out Vector3)
static Vector3	Lerp (Vector3 v1, Vector3 v2, float f)
	static function equivalent to Lerp(Vector3, float)
static void	Lerp (ref Vector3 v1, ref Vector3 v2, float f, out Vector3 result)
	static function equivalent to Lerp(ref Vector3, float, out Vector3)
static Vector3	Slerp (Vector3 v1, Vector3 v2, float f)
	static function equivalent to Slerp(Vector3, float)
static void	Slerp (ref Vector3 v1, ref Vector3 v2, float f, out Vector3 result)
	static function equivalent to Slerp(ref Vector3, float, out Vector3)
static Vector3	MoveTo (Vector3 v1, Vector3 v2, float length)
	static function equivalent to MoveTo(Vector3, float)
static void	MoveTo (ref Vector3 v1, ref Vector3 v2, float length, out Vector3 result)
	static function equivalent to MoveTo(ref Vector3, float, out Vector3)
static Vector3	TurnTo (Vector3 v1, Vector3 v2, float angle)
	static function equivalent to TurnTo(Vector3, float)
static void	TurnTo (ref Vector3 v1, ref Vector3 v2, float angle, out Vector3 result)
	static function equivalent to TurnTo(ref Vector3, float, out Vector3)
static float	Angle (Vector3 v1, Vector3 v2)
	static function equivalent to Angle(Vector3)
static float	Angle (ref Vector3 v1, ref Vector3 v2)
	static function equivalent to Angle(ref Vector3)
static Vector3	RotateX (Vector3 v, float angle)
	static function equivalent to RotateX(float)
static void	RotateX (ref Vector3 v, float angle, out Vector3 result)
	static function equivalent to RotateX(float, out Vector3)
static Vector3	RotateX (Vector3 v, Vector2 rotation)
	static function equivalent to RotateX(Vector2)
static void	RotateX (ref Vector3 v, ref Vector2 rotation, out Vector3 result)
	static function equivalent to RotateX(ref Vector2, out Vector3)
static Vector3	RotateY (Vector3 v, float angle)
	static function equivalent to RotateY(float)
static void	RotateY (ref Vector3 v, float angle, out Vector3 result)
	static function equivalent to RotateY(float, out Vector3)
static Vector3	RotateY (Vector3 v, Vector2 rotation)
	static function equivalent to RotateY(Vector2)
static void	RotateY (ref Vector3 v, ref Vector2 rotation, out Vector3 result)
	static function equivalent to RotateY(ref Vector2, out Vector3)
static Vector3	RotateZ (Vector3 v, float angle)
	static function equivalent to RotateZ(float)
static void	RotateZ (ref Vector3 v, float angle, out Vector3 result)
	static function equivalent to RotateZ(float, out Vector3)
static Vector3	RotateZ (Vector3 v, Vector2 rotation)
	static function equivalent to RotateZ(Vector2)
static void	RotateZ (ref Vector3 v, ref Vector2 rotation, out Vector3 result)
	static function equivalent to RotateZ(ref Vector2, out Vector3)
static Vector3	Reflect (Vector3 v, Vector3 normal)
	static function equivalent to Reflect(Vector3)
static void	Reflect (ref Vector3 v, ref Vector3 normal, out Vector3 result)
	static function equivalent to Reflect(ref Vector3, out Vector3)
static Vector3	Perpendicular (Vector3 v)
	static function equivalent to Perpendicular()
static void	Perpendicular (ref Vector3 v, out Vector3 result)
	static function equivalent to Perpendicular(out Vector3)
static Vector3	ProjectOnLine (Vector3 v, Vector3 point, Vector3 direction)
	static function equivalent to ProjectOnLine(Vector3, Vector3)
static void	ProjectOnLine (ref Vector3 v, ref Vector3 point, ref Vector3 direction, out Vector3 result)
	static function equivalent to ProjectOnLine(ref Vector3, ref Vector3, out Vector3)
static Vector3	Add (Vector3 v1, Vector3 v2)
	static function equivalent to Add(Vector3)
static void	Add (ref Vector3 v1, ref Vector3 v2, out Vector3 result)
	static function equivalent to Add(ref Vector3, out Vector3)
static Vector3	Subtract (Vector3 v1, Vector3 v2)
	static function equivalent to Subtract(Vector3)
static void	Subtract (ref Vector3 v1, ref Vector3 v2, out Vector3 result)
	static function equivalent to Subtract(ref Vector3, out Vector3)
static Vector3	Multiply (Vector3 v1, Vector3 v2)
	static function equivalent to Multiply(Vector3)
static void	Multiply (ref Vector3 v1, ref Vector3 v2, out Vector3 result)
	static function equivalent to Multiply(ref Vector3, out Vector3)
static Vector3	Multiply (Vector3 v, float f)
	static function equivalent to Multiply(float)
static void	Multiply (ref Vector3 v, float f, out Vector3 result)
	static function equivalent to Multiply(float, out Vector3)
static Vector3	Divide (Vector3 v1, Vector3 v2)
	static function equivalent to Divide(Vector3)
static void	Divide (ref Vector3 v1, ref Vector3 v2, out Vector3 result)
	static function equivalent to Divide(ref Vector3, out Vector3)
static Vector3	Divide (Vector3 v, float f)
	static function equivalent to Divide(float)
static void	Divide (ref Vector3 v, float f, out Vector3 result)
	static function equivalent to Divide(float, out Vector3)
static Vector3	Negate (Vector3 v)
	static function equivalent to Negate()
static void	Negate (ref Vector3 v, out Vector3 result)
	static function equivalent to Negate(out Vector3)
static bool	operator== (Vector3 v1, Vector3 v2)
	equality operator
static bool	operator!= (Vector3 v1, Vector3 v2)
	not equals operator
static Vector3	operator+ (Vector3 v1, Vector3 v2)
	vector addition operator
static Vector3	operator+ (Vector3 v, float f)
	adds a scalar float to each element of a vector
static Vector3	operator+ (float f, Vector3 v)
	adds a scalar float to each element of a vector
static Vector3	operator- (Vector3 v1, Vector3 v2)
	vector subtraction operator
static Vector3	operator- (Vector3 v, float f)
	subtract a scalar float from each element of a vector
static Vector3	operator- (float f, Vector3 v)
	creates a new vector consisting of {f, f, f}, and then subtracts v from it
static Vector3	operator- (Vector3 v)
	unary minus operator
static Vector3	operator* (Vector3 v1, Vector3 v2)
	multiplication operator
static Vector3	operator* (Vector3 v, float f)
	multiply each element of vector by scalar float
static Vector3	operator* (float f, Vector3 v)
	multiply each element of vector by scalar float
static Vector3	operator/ (Vector3 v1, Vector3 v2)
	division operator
static Vector3	operator/ (Vector3 v, float f)
	divide each element of a vector by a scalar float
static Vector3	operator/ (float f, Vector3 v)
	create a new vector consisting of {f, f, f} and divide it by vec
Public Attributes
float	X
	X.
float	Y
	Y.
float	Z
	Z.
Static Public Attributes
static readonly Vector3	Zero = new Vector3(0.0f, 0.0f, 0.0f)
	return a vector of all zeros
static readonly Vector3	One = new Vector3(1.0f, 1.0f, 1.0f)
	return a vector of all ones
static readonly Vector3	UnitX = new Vector3(1.0f, 0.0f, 0.0f)
	return a Vector3 with the x component set to one, and all others set to zero
static readonly Vector3	UnitY = new Vector3(0.0f, 1.0f, 0.0f)
	return a Vector3 with the y component set to one, and all others set to zero
static readonly Vector3	UnitZ = new Vector3(0.0f, 0.0f, 1.0f)
	return a Vector3 with the z component set to one, and all others set to zero
Properties
float	R [get, set]
	Red.
float	G [get, set]
	Green.
float	B [get, set]
	Blue.
Vector3	Xxx [get]
Vector3	Yxx [get]
Vector3	Zxx [get]
Vector3	Xyx [get]
Vector3	Yyx [get]
Vector3	Zyx [get, set]
Vector3	Xzx [get]
Vector3	Yzx [get, set]
Vector3	Zzx [get]
Vector3	Xxy [get]
Vector3	Yxy [get]
Vector3	Zxy [get, set]
Vector3	Xyy [get]
Vector3	Yyy [get]
Vector3	Zyy [get]
Vector3	Xzy [get, set]
Vector3	Yzy [get]
Vector3	Zzy [get]
Vector3	Xxz [get]
Vector3	Yxz [get, set]
Vector3	Zxz [get]
Vector3	Xyz [get, set]
Vector3	Yyz [get]
Vector3	Zyz [get]
Vector3	Xzz [get]
Vector3	Yzz [get]
Vector3	Zzz [get]
Vector2	Xx [get]
Vector2	Yx [get, set]
Vector2	Zx [get, set]
Vector2	Xy [get, set]
Vector2	Yy [get]
Vector2	Zy [get, set]
Vector2	Xz [get, set]
Vector2	Yz [get, set]
Vector2	Zz [get]
Vector4	Xyz0 [get]
	return a 4 element vector consisting of the current vector with the w component set to 0
Vector4	Xyz1 [get]
	return a 4 element vector consisting of the current vector with the w component set to 1

---

Detailed Description

vector of 3 floats

---

Constructor & Destructor Documentation

Vector3	(	float	x,
		float	y,
		float	z
	)

constructor taking three floats

Parameters:

x	x value to initialize with
y	y value to initialize with
z	z value to initialize with

Vector3	(	Vector2	xy,
		float	z
	)

constructor taking a Vector2 and a float

Parameters:

xy	x and y values to initialize with
z	z value to initialize with

Vector3

(

float

f

)

constructor taking one float

Parameters:

f

f

---

Member Function Documentation

Vector3 Abs

(

)

element wise absolute value

Returns:

element wise absolute value of this

void Abs

(

out Vector3

result

)

element wise absolute value

Parameters:

result

element wise absolute value of this

static Vector3 Abs

(

Vector3

v

)

[static]

static function equivalent to Abs()

Parameters:

v

vector

Returns:

element wise absolute value of v

static void Abs	(	ref Vector3	v,
		out Vector3	result
	)		[static]

static function equivalent to Abs(out Vector3)

Parameters:

v	vector
result	element wise absolute value of v

static Vector3 Add	(	Vector3	v1,
		Vector3	v2
	)		[static]

static function equivalent to Add(Vector3)

Parameters:

v1	vector 1
v2	vector 2

Returns:

v1 + v2

static void Add	(	ref Vector3	v1,
		ref Vector3	v2,
		out Vector3	result
	)		[static]

static function equivalent to Add(ref Vector3, out Vector3)

Parameters:

v1	vector 1
v2	vector 2
result	v1 + v2

Vector3 Add

(

Vector3

v

)

return this + v

Parameters:

v

vector

Returns:

this + v

void Add	(	ref Vector3	v,
		out Vector3	result
	)

result = this + v

Parameters:

v	vector
result	this + v

float Angle

(

Vector3

v

)

get the angle between this and the input vector

Parameters:

v	the vector to get the angle to

Returns:

the angle between this and v

float Angle

(

ref Vector3

v

)

get the angle between this and the input vector

Parameters:

v	the vector to get the angle to

Returns:

the angle between this and v

static float Angle	(	Vector3	v1,
		Vector3	v2
	)		[static]

static function equivalent to Angle(Vector3)

Parameters:

v1	vector 1
v2	vector 2

Returns:

the angle between v1 and v2

static float Angle	(	ref Vector3	v1,
		ref Vector3	v2
	)		[static]

static function equivalent to Angle(ref Vector3)

Parameters:

v1	vector 1
v2	vector 2

Returns:

the angle between v1 and v2

Vector3 Clamp	(	Vector3	min,
		Vector3	max
	)

element wise clamp

Parameters:

min	min values to clamp against
max	max values to clamp against

Returns:

a new vector consisting of each element of this clamped between min and max

void Clamp	(	ref Vector3	min,
		ref Vector3	max,
		out Vector3	result
	)

element wise clamp

Parameters:

min	min values to clamp against
max	max values to clamp against
result	a new vector consisting of each element of this clamped between min and max

Vector3 Clamp	(	float	min,
		float	max
	)

element wise clamp

Parameters:

min	min value to clamp against
max	max value to clamp against

Returns:

a new vector consisting of each element of this clamped between min and max

void Clamp	(	float	min,
		float	max,
		out Vector3	result
	)

element wise clamp

Parameters:

min	min value to clamp against
max	max value to clamp against
result	a new vector consisting of each element of this clamped between min and max

static Vector3 Clamp	(	Vector3	v,
		Vector3	min,
		Vector3	max
	)		[static]

static function equivalent to Clamp(Vector3, Vector3)

Parameters:

v	vector
min	min values to clamp against
max	max values to clamp against

Returns:

a new vector consisting of each element of v clamped between min and max

static void Clamp	(	ref Vector3	v,
		ref Vector3	min,
		ref Vector3	max,
		out Vector3	result
	)		[static]

static function equivalent to Clamp(ref Vector3, ref Vector3, out Vector3)

Parameters:

v	vector
min	min values to clamp against
max	max values to clamp against
result	a new vector consisting of each element of v clamped between min and max

static Vector3 Clamp	(	Vector3	v,
		float	min,
		float	max
	)		[static]

static function equivalent to Clamp(float, float)

Parameters:

v	vector
min	min value to clamp against
max	max value to clamp against

Returns:

a new vector consisting of each element of v clamped between min and max

static void Clamp	(	ref Vector3	v,
		float	min,
		float	max,
		out Vector3	result
	)		[static]

static function equivalent to Clamp(float, float, out Vector3)

Parameters:

v	vector
min	min value to clamp against
max	max value to clamp against
result	a new vector consisting of each element of v clamped between min and max

void Cross	(	ref Vector3	v,
		out Vector3	result
	)

cross product

Parameters:

v	vector to take the cross product with
result	cross product of this and v

static Vector3 Cross	(	Vector3	v1,
		Vector3	v2
	)		[static]

static function equivalent to Cross(Vector3)

Parameters:

v1	vector 1
v2	vector 2

Returns:

cross product of v1 and v2

static void Cross	(	ref Vector3	v1,
		ref Vector3	v2,
		out Vector3	result
	)		[static]

static function equivalent to Cross(ref Vector3, out Vector3)

Parameters:

v1	vector 1
v2	vector 2
result	cross product of v1 and v2

Vector3 Cross

(

Vector3

v

)

cross product

Parameters:

v	vector to take the cross product with

Returns:

cross product of this and v

float Distance

(

ref Vector3

v

)

get the distance between this and another vector

Parameters:

v	the vector to get the distance to

Returns:

the distance bwteen this and the other vector

static float Distance	(	Vector3	v1,
		Vector3	v2
	)		[static]

static function equivalent to Distance(Vector3)

Parameters:

v1	vector 1
v2	vector 2

Returns:

the distance bwteen v1 and v2

static float Distance	(	ref Vector3	v1,
		ref Vector3	v2
	)		[static]

static function equivalent to Distance(ref Vector3)

Parameters:

v1	vector 1
v2	vector 2

Returns:

the distance bwteen v1 and v2

float Distance

(

Vector3

v

)

get the distance between this and another vector

Parameters:

v	the vector to get the distance to

Returns:

the distance bwteen this and the other vector

float DistanceSquared

(

Vector3

v

)

get the distance squared between this and another vector

Parameters:

v	the vector to get the distance squared to

Returns:

the distance between this and the other vector squared

static float DistanceSquared	(	Vector3	v1,
		Vector3	v2
	)		[static]

static function equivalent to DistanceSquared(Vector3)

Parameters:

v1	vector 1
v2	vector 2

Returns:

the distance between v1 and v2 squared

static float DistanceSquared	(	ref Vector3	v1,
		ref Vector3	v2
	)		[static]

static function equivalent to DistanceSquared(ref Vector3)

Parameters:

v1	vector 1
v2	vector 2

Returns:

the distance between v1 and v2 squared

float DistanceSquared

(

ref Vector3

v

)

get the distance squared between this and another vector

Parameters:

v	the vector to get the distance squared to

Returns:

the distance between this and the other vector squared

Vector3 Divide

(

Vector3

v

)

return this / v

Parameters:

v

vector

Returns:

this / v

Vector3 Divide

(

float

f

)

return this / f

Parameters:

f

scalar

Returns:

this / f

void Divide	(	ref Vector3	v,
		out Vector3	result
	)

result = this / v

Parameters:

v	vector
result	this / v

void Divide	(	float	f,
		out Vector3	result
	)

result = this / f

Parameters:

f	scalar
result	this / f

static Vector3 Divide	(	Vector3	v1,
		Vector3	v2
	)		[static]

static function equivalent to Divide(Vector3)

Parameters:

v1	vector 1
v2	vector 2

Returns:

v1 / v2

static void Divide	(	ref Vector3	v1,
		ref Vector3	v2,
		out Vector3	result
	)		[static]

static function equivalent to Divide(ref Vector3, out Vector3)

Parameters:

v1	vector 1
v2	vector 2
result	v1 / v2

static Vector3 Divide	(	Vector3	v,
		float	f
	)		[static]

static function equivalent to Divide(float)

Parameters:

v	vector
f	scalar

Returns:

v / f

static void Divide	(	ref Vector3	v,
		float	f,
		out Vector3	result
	)		[static]

static function equivalent to Divide(float, out Vector3)

Parameters:

v	vector
f	scalar
result	v / f

float Dot

(

ref Vector3

v

)

dot product of this and v

Parameters:

v	vector to take the dot product with

Returns:

dot product of this and v

static float Dot	(	Vector3	v1,
		Vector3	v2
	)		[static]

static function equivalent to Dot(Vector3)

Parameters:

v1	vector 1
v2	vector 2

Returns:

dot product of v1 and v2

static float Dot	(	ref Vector3	v1,
		ref Vector3	v2
	)		[static]

static function equivalent to Dot(ref Vector3)

Parameters:

v1	vector 1
v2	vector 2

Returns:

dot product of v1 and v2

float Dot

(

Vector3

v

)

dot product of this and v

Parameters:

v	vector to take the dot product with

Returns:

dot product of this and v

bool Equals	(	Vector3	v,
		float	epsilon
	)

equality test with an epsilon

Parameters:

v	the vector to compare this to
epsilon	the epsilon to use in comparison

Returns:

true if for every element n, abs(this[n] - v[n]) <= epsilon, false otherwise

bool Equals

(

Vector3

v

)

equality test

Parameters:

v	the vector to compare this to

Returns:

true if this == v, false otherwise

override bool Equals

(

Object

o

)

equality test

Parameters:

o	the object to compare this to

Returns:

true if this == o, false otherwise

override int GetHashCode

(

)

gets the hash code for this vector

Returns:

integer hash code

bool IsInfinity

(

)

test if any elements of this are Infinity

Returns:

true if any elements of this are Infinity, false otherwise

bool IsNaN

(

)

test if any elements of this are NaN

Returns:

true if any elements of this are NaN, false otherwise

bool IsOne

(

)

test if all elements of this are one

Returns:

true if all elements of this are one, false otherwise

bool IsUnit

(

float

epsilon

)

unit vector test

Parameters:

epsilon

epsilon used to test

Returns:

true if the absolute value of the vector length minus one is <= epsilon, false otherwise

bool IsZero

(

)

test if all elements of this are zero

Returns:

true if all elements of this are zero, false otherwise

static float Length

(

Vector3

v

)

[static]

static function equivalent to Length()

Parameters:

v

vector

Returns:

the length of the vector

static float Length

(

ref Vector3

v

)

[static]

static function equivalent to Length()

Parameters:

v

vector

Returns:

the length of the vector

float Length

(

)

return the length of this vector

Returns:

the length of this vector

float LengthSquared

(

)

return the length squared of this vector

Returns:

the length squared of this vector

static float LengthSquared

(

Vector3

v

)

[static]

static function equivalent to LengthSquared()

Parameters:

v

vector

Returns:

the length squared of the vector

static float LengthSquared

(

ref Vector3

v

)

[static]

static function equivalent to LengthSquared()

Parameters:

v

vector

Returns:

the length squared of the vector

void Lerp	(	ref Vector3	v,
		float	f,
		out Vector3	result
	)

lerp between this and the other vector

Parameters:

v	the other vector to lerp to
f	lerp amount
result	a Vector3 where each element is the result of lerping f between the corresponding elements of this and other

static Vector3 Lerp	(	Vector3	v1,
		Vector3	v2,
		float	f
	)		[static]

static function equivalent to Lerp(Vector3, float)

Parameters:

v1	vector 1
v2	vector 2
f	lerp amount

Returns:

a Vector3 where each element is the result of lerping f between the corresponding elements of v1 and v2

static void Lerp	(	ref Vector3	v1,
		ref Vector3	v2,
		float	f,
		out Vector3	result
	)		[static]

static function equivalent to Lerp(ref Vector3, float, out Vector3)

Parameters:

v1	vector 1
v2	vector 2
f	lerp amount
result	a Vector3 where each element is the result of lerping f between the corresponding elements of v1 and v2

Vector3 Lerp	(	Vector3	v,
		float	f
	)

lerp between this and the other vector

Parameters:

v	the other vector to lerp to
f	lerp amount

Returns:

a Vector3 where each element is the result of lerping f between the corresponding elements of this and other

Vector3 Max

(

Vector3

v

)

element wise max

Parameters:

v	vector to compare to this

Returns:

the max of this and v

void Max	(	ref Vector3	v,
		out Vector3	result
	)

element wise max

Parameters:

v	vector to compare to this
result	the max of this and v

Vector3 Max

(

float

f

)

element wise max

Parameters:

f	scalar to compare to this

Returns:

the max of this and f

void Max	(	float	f,
		out Vector3	result
	)

element wise max

Parameters:

f	scalar to compare to this
result	the max of this and f

static Vector3 Max	(	Vector3	v1,
		Vector3	v2
	)		[static]

static function equivalent to Max(Vector3)

Parameters:

v1	vector 1
v2	vector 2

Returns:

the max of v1 and v2

static void Max	(	ref Vector3	v1,
		ref Vector3	v2,
		out Vector3	result
	)		[static]

static function equivalent to Max(ref Vector3, out Vector3)

Parameters:

v1	vector 1
v2	vector 2
result	the max of v1 and v2

static Vector3 Max	(	Vector3	v,
		float	f
	)		[static]

static function equivalent to Max(float)

Parameters:

v	vector
f	scalar

Returns:

the max of v and f

static void Max	(	ref Vector3	v,
		float	f,
		out Vector3	result
	)		[static]

static function equivalent to Max(float, out Vector3)

Parameters:

v	vector
f	scalar
result	the max of v and f

void Min	(	ref Vector3	v,
		out Vector3	result
	)

element wise min

Parameters:

v	vector to compare to this
result	the min of this and v

Vector3 Min

(

float

f

)

element wise min

Parameters:

f	scalar to compare to this

Returns:

the min of this and f

void Min	(	float	f,
		out Vector3	result
	)

element wise min

Parameters:

f	scalar to compare to this
result	the min of this and f

static Vector3 Min	(	Vector3	v1,
		Vector3	v2
	)		[static]

static function equivalent to Min(Vector3)

Parameters:

v1	vector 1
v2	vector 2

Returns:

the min of v1 and v2

static void Min	(	ref Vector3	v1,
		ref Vector3	v2,
		out Vector3	result
	)		[static]

static function equivalent to Min(ref Vector3, out Vector3)

Parameters:

v1	vector 1
v2	vector 2
result	the min of v1 and v2

static Vector3 Min	(	Vector3	v,
		float	f
	)		[static]

static function equivalent to Min(float)

Parameters:

v	vector
f	scalar

Returns:

the min of v and f

static void Min	(	ref Vector3	v,
		float	f,
		out Vector3	result
	)		[static]

static function equivalent to Min(float, out Vector3)

Parameters:

v	vector
f	scalar
result	the min of v and f

Vector3 Min

(

Vector3

v

)

element wise min

Parameters:

v	vector to compare to this

Returns:

the min of this and v

Vector3 MoveTo	(	Vector3	v,
		float	length
	)

move to target vector by specified length

Parameters:

v	target vector
length	step length

Returns:

a new vector moved to target vector by specified length

void MoveTo	(	ref Vector3	v,
		float	length,
		out Vector3	result
	)

move to target vector by specified length

Parameters:

v	target vector
length	step length
result	a new vector moved to target vector by specified length

static Vector3 MoveTo	(	Vector3	v1,
		Vector3	v2,
		float	length
	)		[static]

static function equivalent to MoveTo(Vector3, float)

Parameters:

v1	vector 1
v2	vector 2
length	step length

Returns:

a new vector moved to target vector by specified length

static void MoveTo	(	ref Vector3	v1,
		ref Vector3	v2,
		float	length,
		out Vector3	result
	)		[static]

static function equivalent to MoveTo(ref Vector3, float, out Vector3)

Parameters:

v1	vector 1
v2	vector 2
length	step length
result	a new vector moved to target vector by specified length

void Multiply	(	ref Vector3	v,
		out Vector3	result
	)

result = this * v

Parameters:

v	vector
result	this * v

Vector3 Multiply

(

float

f

)

return this * f

Parameters:

f

scalar

Returns:

this * f

void Multiply	(	float	f,
		out Vector3	result
	)

result = this * f

Parameters:

f	scalar
result	this * f

static void Multiply	(	ref Vector3	v,
		float	f,
		out Vector3	result
	)		[static]

static function equivalent to Multiply(float, out Vector3)

Parameters:

v	vector
f	scalar
result	v * f

static void Multiply	(	ref Vector3	v1,
		ref Vector3	v2,
		out Vector3	result
	)		[static]

static function equivalent to Multiply(ref Vector3, out Vector3)

Parameters:

v1	vector 1
v2	vector 2
result	v1 * v2

static Vector3 Multiply	(	Vector3	v1,
		Vector3	v2
	)		[static]

static function equivalent to Multiply(Vector3)

Parameters:

v1	vector 1
v2	vector 2

Returns:

v1 * v2

static Vector3 Multiply	(	Vector3	v,
		float	f
	)		[static]

static function equivalent to Multiply(float)

Parameters:

v	vector
f	scalar

Returns:

v * f

Vector3 Multiply

(

Vector3

v

)

return this * v

Parameters:

v

vector

Returns:

this * v

void Negate

(

out Vector3

result

)

result = -this

Parameters:

result

-this

Vector3 Negate

(

)

return -this

Returns:

-this

static Vector3 Negate

(

Vector3

v

)

[static]

static function equivalent to Negate()

Parameters:

v

vector

Returns:

-v

static void Negate	(	ref Vector3	v,
		out Vector3	result
	)		[static]

static function equivalent to Negate(out Vector3)

Parameters:

v	vector
result	-v

Vector3 Normalize

(

)

return this vector normalized

Returns:

this vector normalized

static Vector3 Normalize

(

Vector3

v

)

[static]

static function equivalent to Normalize()

Parameters:

v

vector

Returns:

the vector normalized

void Normalize

(

out Vector3

result

)

return this vector normalized

Parameters:

result

this vector normalized

static void Normalize	(	ref Vector3	v,
		out Vector3	result
	)		[static]

static function equivalent to Normalize(out Vector3)

Parameters:

v	vector
result	the vector normalized

static bool operator!=	(	Vector3	v1,
		Vector3	v2
	)		[static]

not equals operator

Parameters:

v1	vector 1
v2	vector 2

Returns:

true if vector 1 != vector 2, false otherwise

static Vector3 operator*	(	Vector3	v,
		float	f
	)		[static]

multiply each element of vector by scalar float

Parameters:

v	the vector to multiply
f	the scalar to multiply each element of the vector by

Returns:

a new vector consisting of each element of vector multiplied by f

static Vector3 operator*	(	float	f,
		Vector3	v
	)		[static]

multiply each element of vector by scalar float

Parameters:

f	the scalar to multiply each element of the vector by
v	the vector to multiply

Returns:

a new vector consisting of each element of vector multiplied by f

static Vector3 operator*	(	Vector3	v1,
		Vector3	v2
	)		[static]

multiplication operator

Parameters:

v1	vector 1
v2	vector 2

Returns:

vector 1 * vector 2

static Vector3 operator+	(	float	f,
		Vector3	v
	)		[static]

adds a scalar float to each element of a vector

Parameters:

f	the scalar float to add each element of the vector
v	the vector to add

Returns:

a new vector with f added to each element of v

static Vector3 operator+	(	Vector3	v,
		float	f
	)		[static]

adds a scalar float to each element of a vector

Parameters:

v	the vector to add
f	the scalar float to add each element of the vector

Returns:

a new vector with f added to each element of v

static Vector3 operator+	(	Vector3	v1,
		Vector3	v2
	)		[static]

vector addition operator

Parameters:

v1	vector 1
v2	vector 2

Returns:

vector 1 + vector 2

static Vector3 operator-	(	Vector3	v1,
		Vector3	v2
	)		[static]

vector subtraction operator

Parameters:

v1	vector 1
v2	vector 2

Returns:

vector 1 - vector 2

static Vector3 operator-	(	float	f,
		Vector3	v
	)		[static]

creates a new vector consisting of {f, f, f}, and then subtracts v from it

Parameters:

f	the scalar that we subtract v from
v	the vector to subtract

Returns:

a new vector consisting of v subtracted from the vector {f, f, f}

static Vector3 operator-	(	Vector3	v,
		float	f
	)		[static]

subtract a scalar float from each element of a vector

Parameters:

v	the vector to subtract from
f	the scalar float to subtract from each element of the vector

Returns:

a new vector with f subtracted from each element of v

static Vector3 operator-

(

Vector3

v

)

[static]

unary minus operator

Parameters:

v	the vector to negate

Returns:

unary minus applied to each member of v

static Vector3 operator/	(	float	f,
		Vector3	v
	)		[static]

create a new vector consisting of {f, f, f} and divide it by vec

Parameters:

f	the scalar to divide by vector
v	the vector to divide by

Returns:

a new vector {f, f, f} divided by v

static Vector3 operator/	(	Vector3	v,
		float	f
	)		[static]

divide each element of a vector by a scalar float

Parameters:

v	the vector to divide by scalar
f	the scalar to divide by

Returns:

a new Vector3 consisting of each element of v divided by f

static Vector3 operator/	(	Vector3	v1,
		Vector3	v2
	)		[static]

division operator

Parameters:

v1	vector 1
v2	vector 2

Returns:

vector 1 / vector 2

static bool operator==	(	Vector3	v1,
		Vector3	v2
	)		[static]

equality operator

Parameters:

v1	vector 1
v2	vector 2

Returns:

true if vector 1 == vector 2, false otherwise

static Vector3 Perpendicular

(

Vector3

v

)

[static]

static function equivalent to Perpendicular()

Parameters:

v

vector

Returns:

a vector perpendicular to v

static void Perpendicular	(	ref Vector3	v,
		out Vector3	result
	)		[static]

static function equivalent to Perpendicular(out Vector3)

Parameters:

v	vector
result	a vector perpendicular to v

Vector3 Perpendicular

(

)

return a vector perpendicular to this

Returns:

a vector perpendicular to this

void Perpendicular

(

out Vector3

result

)

return a vector perpendicular to this

Parameters:

result

a vector perpendicular to this

static void ProjectOnLine	(	ref Vector3	v,
		ref Vector3	point,
		ref Vector3	direction,
		out Vector3	result
	)		[static]

static function equivalent to ProjectOnLine(ref Vector3, ref Vector3, out Vector3)

Parameters:

v	vector
point	line start point
direction	line direction
result	the vector projected onto the line (point,direction)

Vector3 ProjectOnLine	(	Vector3	point,
		Vector3	direction
	)

project this vector onto the line (point,direction)

Parameters:

point	line start point
direction	line direction

Returns:

this vector projected onto the line (point,direction)

static Vector3 ProjectOnLine	(	Vector3	v,
		Vector3	point,
		Vector3	direction
	)		[static]

static function equivalent to ProjectOnLine(Vector3, Vector3)

Parameters:

v	vector
point	line start point
direction	line direction

Returns:

the vector projected onto the line (point,direction)

void ProjectOnLine	(	ref Vector3	point,
		ref Vector3	direction,
		out Vector3	result
	)

project this vector onto the line (point,direction)

Parameters:

point	line start point
direction	line direction
result	this vector projected onto the line (point,direction)

static Vector3 Reflect	(	Vector3	v,
		Vector3	normal
	)		[static]

static function equivalent to Reflect(Vector3)

Parameters:

v	vector
normal	the vector to reflect about

Returns:

the vector reflected about normal

Vector3 Reflect

(

Vector3

normal

)

return this vector reflected about normal

Parameters:

normal

the vector to reflect about

Returns:

this vector reflected about normal

static void Reflect	(	ref Vector3	v,
		ref Vector3	normal,
		out Vector3	result
	)		[static]

static function equivalent to Reflect(ref Vector3, out Vector3)

Parameters:

v	vector
normal	the vector to reflect about
result	the vector reflected about normal

void Reflect	(	ref Vector3	normal,
		out Vector3	result
	)

return this vector reflected about normal

Parameters:

normal	the vector to reflect about
result	this vector reflected about normal

void Repeat	(	ref Vector3	min,
		ref Vector3	max,
		out Vector3	result
	)

element wise repeat

Parameters:

min	min values to repeat over
max	max values to repeat over
result	a new vector consisting of each element of this repeated between min and max

static void Repeat	(	ref Vector3	v,
		float	min,
		float	max,
		out Vector3	result
	)		[static]

static function equivalent to Repeat(float, float, out Vector3)

Parameters:

v	vector
min	min value to repeat over
max	max value to repeat over
result	a new vector consisting of each element of v repeated between min and max

static Vector3 Repeat	(	Vector3	v,
		float	min,
		float	max
	)		[static]

static function equivalent to Repeat(float, float)

Parameters:

v	vector
min	min value to repeat over
max	max value to repeat over

Returns:

a new vector consisting of each element of v repeated between min and max

void Repeat	(	float	min,
		float	max,
		out Vector3	result
	)

element wise repeat

Parameters:

min	min value to repeat over
max	max value to repeat over
result	a new vector consisting of each element of this repeated between min and max

Vector3 Repeat	(	Vector3	min,
		Vector3	max
	)

element wise repeat

Parameters:

min	min values to repeat over
max	max values to repeat over

Returns:

a new vector consisting of each element of this repeated between min and max

Vector3 Repeat	(	float	min,
		float	max
	)

element wise repeat

Parameters:

min	min value to repeat over
max	max value to repeat over

Returns:

a new vector consisting of each element of this repeated between min and max

static Vector3 Repeat	(	Vector3	v,
		Vector3	min,
		Vector3	max
	)		[static]

static function equivalent to Repeat(Vector3, Vector3)

Parameters:

v	vector
min	min values to repeat over
max	max values to repeat over

Returns:

a new vector consisting of each element of v repeated between min and max

static void Repeat	(	ref Vector3	v,
		ref Vector3	min,
		ref Vector3	max,
		out Vector3	result
	)		[static]

static function equivalent to Repeat(ref Vector3, ref Vector3, out Vector3)

Parameters:

v	vector
min	min values to repeat over
max	max values to repeat over
result	a new vector consisting of each element of v repeated between min and max

Vector3 RotateX

(

Vector2

rotation

)

rotate this around the x axis by an angle

Parameters:

rotation

a vector containing the cos and sin of the angle to rotate by

Returns:

the rotated vector

Vector3 RotateX

(

float

angle

)

rotate this around the x axis by an angle

Parameters:

angle

angle to rotate by

Returns:

the rotated vector

void RotateX	(	float	angle,
		out Vector3	result
	)

rotate this around the x axis by an angle

Parameters:

angle	angle to rotate by
result	the rotated vector

void RotateX	(	ref Vector2	rotation,
		out Vector3	result
	)

rotate this around the x axis by an angle

Parameters:

rotation	a vector containing the cos and sin of the angle to rotate by
result	the rotated vector

static void RotateX	(	ref Vector3	v,
		float	angle,
		out Vector3	result
	)		[static]

static function equivalent to RotateX(float, out Vector3)

Parameters:

v	vector
angle	angle to rotate by
result	the rotated vector

static Vector3 RotateX	(	Vector3	v,
		Vector2	rotation
	)		[static]

static function equivalent to RotateX(Vector2)

Parameters:

v	vector
rotation	a vector containing the cos and sin of the angle to rotate by

Returns:

the rotated vector

static void RotateX	(	ref Vector3	v,
		ref Vector2	rotation,
		out Vector3	result
	)		[static]

static function equivalent to RotateX(ref Vector2, out Vector3)

Parameters:

v	vector
rotation	a vector containing the cos and sin of the angle to rotate by
result	the rotated vector

static Vector3 RotateX	(	Vector3	v,
		float	angle
	)		[static]

static function equivalent to RotateX(float)

Parameters:

v	vector
angle	angle to rotate by

Returns:

the rotated vector

Vector3 RotateY

(

Vector2

rotation

)

rotate this around the y axis by an angle

Parameters:

rotation

a vector containing the cos and sin of the angle to rotate by

Returns:

the rotated vector

static void RotateY	(	ref Vector3	v,
		ref Vector2	rotation,
		out Vector3	result
	)		[static]

static function equivalent to RotateY(ref Vector2, out Vector3)

Parameters:

v	vector
rotation	a vector containing the cos and sin of the angle to rotate by
result	the rotated vector

void RotateY	(	float	angle,
		out Vector3	result
	)

rotate this around the y axis by an angle

Parameters:

angle	angle to rotate by
result	the rotated vector

Vector3 RotateY

(

float

angle

)

rotate this around the y axis by an angle

Parameters:

angle

angle to rotate by

Returns:

the rotated vector

static Vector3 RotateY	(	Vector3	v,
		float	angle
	)		[static]

static function equivalent to RotateY(float)

Parameters:

v	vector
angle	angle to rotate by

Returns:

the rotated vector

void RotateY	(	ref Vector2	rotation,
		out Vector3	result
	)

rotate this around the y axis by an angle

Parameters:

rotation	a vector containing the cos and sin of the angle to rotate by
result	the rotated vector

static void RotateY	(	ref Vector3	v,
		float	angle,
		out Vector3	result
	)		[static]

static function equivalent to RotateY(float, out Vector3)

Parameters:

v	vector
angle	angle to rotate by
result	the rotated vector

static Vector3 RotateY	(	Vector3	v,
		Vector2	rotation
	)		[static]

static function equivalent to RotateY(Vector2)

Parameters:

v	vector
rotation	a vector containing the cos and sin of the angle to rotate by

Returns:

the rotated vector

Vector3 RotateZ

(

Vector2

rotation

)

rotate this around the z axis by an angle

Parameters:

rotation

a vector containing the cos and sin of the angle to rotate by

Returns:

the rotated vector

static Vector3 RotateZ	(	Vector3	v,
		Vector2	rotation
	)		[static]

static function equivalent to RotateZ(Vector2)

Parameters:

v	vector
rotation	a vector containing the cos and sin of the angle to rotate by

Returns:

the rotated vector

static void RotateZ	(	ref Vector3	v,
		ref Vector2	rotation,
		out Vector3	result
	)		[static]

static function equivalent to RotateZ(ref Vector2, out Vector3)

Parameters:

v	vector
rotation	a vector containing the cos and sin of the angle to rotate by
result	the rotated vector

static void RotateZ	(	ref Vector3	v,
		float	angle,
		out Vector3	result
	)		[static]

static function equivalent to RotateZ(float, out Vector3)

Parameters:

v	vector
angle	angle to rotate by
result	the rotated vector

Vector3 RotateZ

(

float

angle

)

rotate this around the z axis by an angle

Parameters:

angle

angle to rotate by

Returns:

the rotated vector

static Vector3 RotateZ	(	Vector3	v,
		float	angle
	)		[static]

static function equivalent to RotateZ(float)

Parameters:

v	vector
angle	angle to rotate by

Returns:

the rotated vector

void RotateZ	(	ref Vector2	rotation,
		out Vector3	result
	)

rotate this around the z axis by an angle

Parameters:

rotation	a vector containing the cos and sin of the angle to rotate by
result	the rotated vector

void RotateZ	(	float	angle,
		out Vector3	result
	)

rotate this around the z axis by an angle

Parameters:

angle	angle to rotate by
result	the rotated vector

static Vector3 Slerp	(	Vector3	v1,
		Vector3	v2,
		float	f
	)		[static]

static function equivalent to Slerp(Vector3, float)

Parameters:

v1	vector 1
v2	vector 2
f	slerp amount

Returns:

slerp between v1 and v2

Vector3 Slerp	(	Vector3	v,
		float	f
	)

slerp between this and the other vector

Parameters:

v	the other vector to slerp to
f	slerp amount

Returns:

slerp between this and v

void Slerp	(	ref Vector3	v,
		float	f,
		out Vector3	result
	)

slerp between this and the other vector

Parameters:

v	the other vector to slerp to
f	slerp amount
result	slerp between this and v

static void Slerp	(	ref Vector3	v1,
		ref Vector3	v2,
		float	f,
		out Vector3	result
	)		[static]

static function equivalent to Slerp(ref Vector3, float, out Vector3)

Parameters:

v1	vector 1
v2	vector 2
f	slerp amount
result	slerp between v1 and v2

static void Subtract	(	ref Vector3	v1,
		ref Vector3	v2,
		out Vector3	result
	)		[static]

static function equivalent to Subtract(ref Vector3, out Vector3)

Parameters:

v1	vector 1
v2	vector 2
result	v1 - v2

void Subtract	(	ref Vector3	v,
		out Vector3	result
	)

result = this - v

Parameters:

v	vector
result	this - v

Vector3 Subtract

(

Vector3

v

)

return this - v

Parameters:

v

vector

Returns:

this - v

static Vector3 Subtract	(	Vector3	v1,
		Vector3	v2
	)		[static]

static function equivalent to Subtract(Vector3)

Parameters:

v1	vector 1
v2	vector 2

Returns:

v1 - v2

override string ToString

(

)

return the string representation of this

Returns:

the string representation of this

static Vector3 TurnTo	(	Vector3	v1,
		Vector3	v2,
		float	angle
	)		[static]

static function equivalent to TurnTo(Vector3, float)

Parameters:

v1	vector 1
v2	vector 2
angle	step angle

Returns:

a new vector turned to target vector by specified angle

void TurnTo	(	ref Vector3	v,
		float	angle,
		out Vector3	result
	)

turn to target vector by specified angle

Parameters:

v	target vector
angle	step angle
result	a new vector turned to target vector by specified angle

static void TurnTo	(	ref Vector3	v1,
		ref Vector3	v2,
		float	angle,
		out Vector3	result
	)		[static]

static function equivalent to TurnTo(ref Vector3, float, out Vector3)

Parameters:

v1	vector 1
v2	vector 2
angle	step angle
result	a new vector turned to target vector by specified angle

Vector3 TurnTo	(	Vector3	v,
		float	angle
	)

turn to target vector by specified angle

Parameters:

v	target vector
angle	step angle

Returns:

a new vector turned to target vector by specified angle

---

Member Data Documentation

readonly Vector3 One = new Vector3(1.0f, 1.0f, 1.0f) [static]

return a vector of all ones

Returns:

a vector of all ones

readonly Vector3 UnitX = new Vector3(1.0f, 0.0f, 0.0f) [static]

return a Vector3 with the x component set to one, and all others set to zero

Returns:

a Vector3 with the x component set to one, and all others set to zero

readonly Vector3 UnitY = new Vector3(0.0f, 1.0f, 0.0f) [static]

return a Vector3 with the y component set to one, and all others set to zero

Returns:

a Vector3 with the y component set to one, and all others set to zero

readonly Vector3 UnitZ = new Vector3(0.0f, 0.0f, 1.0f) [static]

return a Vector3 with the z component set to one, and all others set to zero

Returns:

a Vector3 with the z component set to one, and all others set to zero

float X

X.

float Y

Y.

float Z

Z.

readonly Vector3 Zero = new Vector3(0.0f, 0.0f, 0.0f) [static]

return a vector of all zeros

Returns:

a vector of all zeros

---

Property Documentation

float B [get, set]

Blue.

float G [get, set]

Green.

float R [get, set]

Red.

Vector2 Xx [get]

return a new vector consisting of the current vector's x, x values

Returns:

a new vector consisting of the current vector's x, x values

Vector3 Xxx [get]

return a new vector consisting of the current vector's x, x, x values

Returns:

a new vector consisting of the current vector's x, x, x values

Vector3 Xxy [get]

return a new vector consisting of the current vector's x, x, y values

Returns:

a new vector consisting of the current vector's x, x, y values

Vector3 Xxz [get]

return a new vector consisting of the current vector's x, x, z values

Returns:

a new vector consisting of the current vector's x, x, z values

Vector2 Xy [get, set]

return a new vector consisting of, or set, the current vector's x, y values

Returns:

a new vector consisting of the current vector's x, y values

Vector3 Xyx [get]

return a new vector consisting of the current vector's x, y, x values

Returns:

a new vector consisting of the current vector's x, y, x values

Vector3 Xyy [get]

return a new vector consisting of the current vector's x, y, y values

Returns:

a new vector consisting of the current vector's x, y, y values

Vector3 Xyz [get, set]

return a new vector consisting of, or set, the current vector's x, y, z values

Returns:

a new vector consisting of the current vector's x, y, z values

Vector4 Xyz0 [get]

return a 4 element vector consisting of the current vector with the w component set to 0

Returns:

a 4 element vector consisting of the current vector with the w component set to 0

Vector4 Xyz1 [get]

return a 4 element vector consisting of the current vector with the w component set to 1

Returns:

a 4 element vector consisting of the current vector with the w component set to 1

Vector2 Xz [get, set]

return a new vector consisting of, or set, the current vector's x, z values

Returns:

a new vector consisting of the current vector's x, z values

Vector3 Xzx [get]

return a new vector consisting of the current vector's x, z, x values

Returns:

a new vector consisting of the current vector's x, z, x values

Vector3 Xzy [get, set]

return a new vector consisting of, or set, the current vector's x, z, y values

Returns:

a new vector consisting of the current vector's x, z, y values

Vector3 Xzz [get]

return a new vector consisting of the current vector's x, z, z values

Returns:

a new vector consisting of the current vector's x, z, z values

Vector2 Yx [get, set]

return a new vector consisting of, or set, the current vector's y, x values

Returns:

a new vector consisting of the current vector's y, x values

Vector3 Yxx [get]

return a new vector consisting of the current vector's y, x, x values

Returns:

a new vector consisting of the current vector's y, x, x values

Vector3 Yxy [get]

return a new vector consisting of the current vector's y, x, y values

Returns:

a new vector consisting of the current vector's y, x, y values

Vector3 Yxz [get, set]

return a new vector consisting of, or set, the current vector's y, x, z values

Returns:

a new vector consisting of the current vector's y, x, z values

Vector2 Yy [get]

return a new vector consisting of the current vector's y, y values

Returns:

a new vector consisting of the current vector's y, y values

Vector3 Yyx [get]

return a new vector consisting of the current vector's y, y, x values

Returns:

a new vector consisting of the current vector's y, y, x values

Vector3 Yyy [get]

return a new vector consisting of the current vector's y, y, y values

Returns:

a new vector consisting of the current vector's y, y, y values

Vector3 Yyz [get]

return a new vector consisting of the current vector's y, y, z values

Returns:

a new vector consisting of the current vector's y, y, z values

Vector2 Yz [get, set]

return a new vector consisting of, or set, the current vector's y, z values

Returns:

a new vector consisting of the current vector's y, z values

Vector3 Yzx [get, set]

return a new vector consisting of, or set, the current vector's y, z, x values

Returns:

a new vector consisting of the current vector's y, z, x values

Vector3 Yzy [get]

return a new vector consisting of the current vector's y, z, y values

Returns:

a new vector consisting of the current vector's y, z, y values

Vector3 Yzz [get]

return a new vector consisting of the current vector's y, z, z values

Returns:

a new vector consisting of the current vector's y, z, z values

Vector2 Zx [get, set]

return a new vector consisting of, or set, the current vector's z, x values

Returns:

a new vector consisting of the current vector's z, x values

Vector3 Zxx [get]

return a new vector consisting of the current vector's z, x, x values

Returns:

a new vector consisting of the current vector's z, x, x values

Vector3 Zxy [get, set]

return a new vector consisting of, or set, the current vector's z, x, y values

Returns:

a new vector consisting of the current vector's z, x, y values

Vector3 Zxz [get]

return a new vector consisting of the current vector's z, x, z values

Returns:

a new vector consisting of the current vector's z, x, z values

Vector2 Zy [get, set]

return a new vector consisting of, or set, the current vector's z, y values

Returns:

a new vector consisting of the current vector's z, y values

Vector3 Zyx [get, set]

return a new vector consisting of, or set, the current vector's z, y, x values

Returns:

a new vector consisting of the current vector's z, y, x values

Vector3 Zyy [get]

return a new vector consisting of the current vector's z, y, y values

Returns:

a new vector consisting of the current vector's z, y, y values

Vector3 Zyz [get]

return a new vector consisting of the current vector's z, y, z values

Returns:

a new vector consisting of the current vector's z, y, z values

Vector2 Zz [get]

return a new vector consisting of the current vector's z, z values

Returns:

a new vector consisting of the current vector's z, z values

Vector3 Zzx [get]

return a new vector consisting of the current vector's z, z, x values

Returns:

a new vector consisting of the current vector's z, z, x values

Vector3 Zzy [get]

return a new vector consisting of the current vector's z, z, y values

Returns:

a new vector consisting of the current vector's z, z, y values

Vector3 Zzz [get]

return a new vector consisting of the current vector's z, z, z values

Returns:

a new vector consisting of the current vector's z, z, z values