OpenTK.Vector3 Struct Reference

Represents a 3D vector using three single-precision floating-point numbers. More...

List of all members.

Public Member Functions
	Vector3 (float x, float y, float z)
	Constructs a new Vector3.
	Vector3 (Vector2 v)
	Constructs a new Vector3 from the given Vector2.
	Vector3 (Vector3 v)
	Constructs a new Vector3 from the given Vector3.
	Vector3 (Vector4 v)
	Constructs a new Vector3 from the given Vector4.
void	Add (Vector3 right)
	Add the Vector passed as parameter to this instance.
void	Add (ref Vector3 right)
	Add the Vector passed as parameter to this instance.
void	Sub (Vector3 right)
	Subtract the Vector passed as parameter from this instance.
void	Sub (ref Vector3 right)
	Subtract the Vector passed as parameter from this instance.
void	Mult (float f)
	Multiply this instance by a scalar.
void	Div (float f)
	Divide this instance by a scalar.
void	Normalize ()
	Scales the Vector3 to unit length.
void	NormalizeFast ()
	Scales the Vector3 to approximately unit length.
void	Scale (float sx, float sy, float sz)
	Scales the current Vector3 by the given amounts.
void	Scale (Vector3 scale)
	Scales this instance by the given parameter.
void	Scale (ref Vector3 scale)
	Scales this instance by the given parameter.
override string	ToString ()
	Returns a System.String that represents the current Vector3.
override int	GetHashCode ()
	Returns the hashcode for this instance.
override bool	Equals (object obj)
	Indicates whether this instance and a specified object are equal.
bool	Equals (Vector3 other)
	Indicates whether the current vector is equal to another vector.
Static Public Member Functions
static Vector3	Sub (Vector3 a, Vector3 b)
	Subtract one Vector from another.
static void	Sub (ref Vector3 a, ref Vector3 b, out Vector3 result)
	Subtract one Vector from another.
static Vector3	Mult (Vector3 a, float f)
	Multiply a vector and a scalar.
static void	Mult (ref Vector3 a, float f, out Vector3 result)
	Multiply a vector and a scalar.
static Vector3	Div (Vector3 a, float f)
	Divide a vector by a scalar.
static void	Div (ref Vector3 a, float f, out Vector3 result)
	Divide a vector by a scalar.
static Vector3	Add (Vector3 a, Vector3 b)
	Adds two vectors.
static void	Add (ref Vector3 a, ref Vector3 b, out Vector3 result)
	Adds two vectors.
static Vector3	Subtract (Vector3 a, Vector3 b)
	Subtract one Vector from another.
static void	Subtract (ref Vector3 a, ref Vector3 b, out Vector3 result)
	Subtract one Vector from another.
static Vector3	Multiply (Vector3 vector, float scale)
	Multiplies a vector by a scalar.
static void	Multiply (ref Vector3 vector, float scale, out Vector3 result)
	Multiplies a vector by a scalar.
static Vector3	Multiply (Vector3 vector, Vector3 scale)
	Multiplies a vector by the components a vector (scale).
static void	Multiply (ref Vector3 vector, ref Vector3 scale, out Vector3 result)
	Multiplies a vector by the components of a vector (scale).
static Vector3	Divide (Vector3 vector, float scale)
	Divides a vector by a scalar.
static void	Divide (ref Vector3 vector, float scale, out Vector3 result)
	Divides a vector by a scalar.
static Vector3	Divide (Vector3 vector, Vector3 scale)
	Divides a vector by the components of a vector (scale).
static void	Divide (ref Vector3 vector, ref Vector3 scale, out Vector3 result)
	Divide a vector by the components of a vector (scale).
static Vector3	ComponentMin (Vector3 a, Vector3 b)
	Calculate the component-wise minimum of two vectors.
static void	ComponentMin (ref Vector3 a, ref Vector3 b, out Vector3 result)
	Calculate the component-wise minimum of two vectors.
static Vector3	ComponentMax (Vector3 a, Vector3 b)
	Calculate the component-wise maximum of two vectors.
static void	ComponentMax (ref Vector3 a, ref Vector3 b, out Vector3 result)
	Calculate the component-wise maximum of two vectors.
static Vector3	Min (Vector3 left, Vector3 right)
	Returns the Vector3 with the minimum magnitude.
static Vector3	Max (Vector3 left, Vector3 right)
	Returns the Vector3 with the minimum magnitude.
static Vector3	Clamp (Vector3 vec, Vector3 min, Vector3 max)
	Clamp a vector to the given minimum and maximum vectors.
static void	Clamp (ref Vector3 vec, ref Vector3 min, ref Vector3 max, out Vector3 result)
	Clamp a vector to the given minimum and maximum vectors.
static Vector3	Normalize (Vector3 vec)
	Scale a vector to unit length.
static void	Normalize (ref Vector3 vec, out Vector3 result)
	Scale a vector to unit length.
static Vector3	NormalizeFast (Vector3 vec)
	Scale a vector to approximately unit length.
static void	NormalizeFast (ref Vector3 vec, out Vector3 result)
	Scale a vector to approximately unit length.
static float	Dot (Vector3 left, Vector3 right)
	Calculate the dot (scalar) product of two vectors.
static void	Dot (ref Vector3 left, ref Vector3 right, out float result)
	Calculate the dot (scalar) product of two vectors.
static Vector3	Cross (Vector3 left, Vector3 right)
	Caclulate the cross (vector) product of two vectors.
static void	Cross (ref Vector3 left, ref Vector3 right, out Vector3 result)
	Caclulate the cross (vector) product of two vectors.
static Vector3	Lerp (Vector3 a, Vector3 b, float blend)
	Returns a new Vector that is the linear blend of the 2 given Vectors.
static void	Lerp (ref Vector3 a, ref Vector3 b, float blend, out Vector3 result)
	Returns a new Vector that is the linear blend of the 2 given Vectors.
static Vector3	BaryCentric (Vector3 a, Vector3 b, Vector3 c, float u, float v)
	Interpolate 3 Vectors using Barycentric coordinates.
static void	BaryCentric (ref Vector3 a, ref Vector3 b, ref Vector3 c, float u, float v, out Vector3 result)
	Interpolate 3 Vectors using Barycentric coordinates.
static Vector3	TransformVector (Vector3 vec, Matrix4 mat)
	Transform a direction vector by the given Matrix Assumes the matrix has a bottom row of (0,0,0,1), that is the translation part is ignored.
static void	TransformVector (ref Vector3 vec, ref Matrix4 mat, out Vector3 result)
	Transform a direction vector by the given Matrix Assumes the matrix has a bottom row of (0,0,0,1), that is the translation part is ignored.
static Vector3	TransformNormal (Vector3 norm, Matrix4 mat)
	Transform a Normal by the given Matrix.
static void	TransformNormal (ref Vector3 norm, ref Matrix4 mat, out Vector3 result)
	Transform a Normal by the given Matrix.
static Vector3	TransformNormalInverse (Vector3 norm, Matrix4 invMat)
	Transform a Normal by the (transpose of the) given Matrix.
static void	TransformNormalInverse (ref Vector3 norm, ref Matrix4 invMat, out Vector3 result)
	Transform a Normal by the (transpose of the) given Matrix.
static Vector3	TransformPosition (Vector3 pos, Matrix4 mat)
	Transform a Position by the given Matrix.
static void	TransformPosition (ref Vector3 pos, ref Matrix4 mat, out Vector3 result)
	Transform a Position by the given Matrix.
static Vector3	Transform (Vector3 vec, Matrix4 mat)
	Transform a Vector by the given Matrix.
static void	Transform (ref Vector3 vec, ref Matrix4 mat, out Vector3 result)
	Transform a Vector by the given Matrix.
static Vector3	Transform (Vector3 vec, Quaternion quat)
	Transforms a vector by a quaternion rotation.
static void	Transform (ref Vector3 vec, ref Quaternion quat, out Vector3 result)
	Transforms a vector by a quaternion rotation.
static Vector3	TransformPerspective (Vector3 vec, Matrix4 mat)
	Transform a Vector3 by the given Matrix, and project the resulting Vector4 back to a Vector3.
static void	TransformPerspective (ref Vector3 vec, ref Matrix4 mat, out Vector3 result)
	Transform a Vector3 by the given Matrix, and project the resulting Vector4 back to a Vector3.
static float	CalculateAngle (Vector3 first, Vector3 second)
	Calculates the angle (in radians) between two vectors.
static void	CalculateAngle (ref Vector3 first, ref Vector3 second, out float result)
	Calculates the angle (in radians) between two vectors.
static Vector3	operator+ (Vector3 left, Vector3 right)
	Adds two instances.
static Vector3	operator- (Vector3 left, Vector3 right)
	Subtracts two instances.
static Vector3	operator- (Vector3 vec)
	Negates an instance.
static Vector3	operator* (Vector3 vec, float scale)
	Multiplies an instance by a scalar.
static Vector3	operator* (float scale, Vector3 vec)
	Multiplies an instance by a scalar.
static Vector3	operator/ (Vector3 vec, float scale)
	Divides an instance by a scalar.
static bool	operator== (Vector3 left, Vector3 right)
	Compares two instances for equality.
static bool	operator!= (Vector3 left, Vector3 right)
	Compares two instances for inequality.
Public Attributes
float	X
	The X component of the Vector3.
float	Y
	The Y component of the Vector3.
float	Z
	The Z component of the Vector3.
Static Public Attributes
static readonly Vector3	UnitX = new Vector3(1, 0, 0)
	Defines a unit-length Vector3 that points towards the X-axis.
static readonly Vector3	UnitY = new Vector3(0, 1, 0)
	Defines a unit-length Vector3 that points towards the Y-axis.
static readonly Vector3	UnitZ = new Vector3(0, 0, 1)
	/ Defines a unit-length Vector3 that points towards the Z-axis.
static readonly Vector3	Zero = new Vector3(0, 0, 0)
	Defines a zero-length Vector3.
static readonly Vector3	One = new Vector3(1, 1, 1)
	Defines an instance with all components set to 1.
static readonly int	SizeInBytes = Marshal.SizeOf(new Vector3())
	Defines the size of the Vector3 struct in bytes.
Properties
float	Length [get]
	Gets the length (magnitude) of the vector.
float	LengthFast [get]
	Gets an approximation of the vector length (magnitude).
float	LengthSquared [get]
	Gets the square of the vector length (magnitude).
Vector2	Xy [get, set]
	Gets or sets an OpenTK.Vector2 with the X and Y components of this instance.

---

Detailed Description

Represents a 3D vector using three single-precision floating-point numbers.

The Vector3 structure is suitable for interoperation with unmanaged code requiring three consecutive floats.

Definition at line 38 of file Vector3.cs.

---

Constructor & Destructor Documentation

OpenTK.Vector3.Vector3	(	float	x,
		float	y,
		float	z
	)

Constructs a new Vector3.

Parameters:

	x	The x component of the Vector3.
	y	The y component of the Vector3.
	z	The z component of the Vector3.

Definition at line 67 of file Vector3.cs.

        {
            X = x;
            Y = y;
            Z = z;
        }

OpenTK.Vector3.Vector3

(

Vector2

v

)

Constructs a new Vector3 from the given Vector2.

Parameters:

v

The Vector2 to copy components from.

Definition at line 78 of file Vector3.cs.

        {
            X = v.X;
            Y = v.Y;
            Z = 0.0f;
        }

OpenTK.Vector3.Vector3

(

Vector3

v

)

Constructs a new Vector3 from the given Vector3.

Parameters:

v

The Vector3 to copy components from.

Definition at line 89 of file Vector3.cs.

        {
            X = v.X;
            Y = v.Y;
            Z = v.Z;
        }

OpenTK.Vector3.Vector3

(

Vector4

v

)

Constructs a new Vector3 from the given Vector4.

Parameters:

v

The Vector4 to copy components from.

Definition at line 100 of file Vector3.cs.

        {
            X = v.X;
            Y = v.Y;
            Z = v.Z;
        }

---

Member Function Documentation

static void OpenTK.Vector3.Add	(	ref Vector3	a,
		ref Vector3	b,
		out Vector3	result
	)			[static]

Adds two vectors.

Parameters:

	a	Left operand.
	b	Right operand.
	result	Result of operation.

Definition at line 483 of file Vector3.cs.

        {
            result = new Vector3(a.X + b.X, a.Y + b.Y, a.Z + b.Z);
        }

static Vector3 OpenTK.Vector3.Add	(	Vector3	a,
		Vector3	b
	)			[static]

Adds two vectors.

Parameters:

	a	Left operand.
	b	Right operand.

Returns:

Result of operation.

Definition at line 471 of file Vector3.cs.

        {
            Add(ref a, ref b, out a);
            return a;
        }

void OpenTK.Vector3.Add

(

ref Vector3

right

)

Add the Vector passed as parameter to this instance.

Parameters:

right

Right operand. This parameter is only read from.

Definition at line 129 of file Vector3.cs.

        {
            this.X += right.X;
            this.Y += right.Y;
            this.Z += right.Z;
        }

void OpenTK.Vector3.Add

(

Vector3

right

)

Add the Vector passed as parameter to this instance.

Parameters:

right

Right operand. This parameter is only read from.

Definition at line 118 of file Vector3.cs.

        {
            this.X += right.X;
            this.Y += right.Y;
            this.Z += right.Z;
        }

static void OpenTK.Vector3.BaryCentric	(	ref Vector3	a,
		ref Vector3	b,
		ref Vector3	c,
		float	u,
		float	v,
		out Vector3	result
	)			[static]

Interpolate 3 Vectors using Barycentric coordinates.

Parameters:

	a	First input Vector.
	b	Second input Vector.
	c	Third input Vector.
	u	First Barycentric Coordinate.
	v	Second Barycentric Coordinate.
	result	Output Vector. a when u=v=0, b when u=1,v=0, c when u=0,v=1, and a linear combination of a,b,c otherwise

Definition at line 917 of file Vector3.cs.

        {
            result = a; // copy

            Vector3 temp = b; // copy
            Subtract(ref temp, ref a, out temp);
            Multiply(ref temp, u, out temp);
            Add(ref result, ref temp, out result);

            temp = c; // copy
            Subtract(ref temp, ref a, out temp);
            Multiply(ref temp, v, out temp);
            Add(ref result, ref temp, out result);
        }

static Vector3 OpenTK.Vector3.BaryCentric	(	Vector3	a,
		Vector3	b,
		Vector3	c,
		float	u,
		float	v
	)			[static]

Interpolate 3 Vectors using Barycentric coordinates.

Parameters:

	a	First input Vector
	b	Second input Vector
	c	Third input Vector
	u	First Barycentric Coordinate
	v	Second Barycentric Coordinate

Returns:

a when u=v=0, b when u=1,v=0, c when u=0,v=1, and a linear combination of a,b,c otherwise

Definition at line 905 of file Vector3.cs.

        {
            return a + u * (b - a) + v * (c - a);
        }

static void OpenTK.Vector3.CalculateAngle	(	ref Vector3	first,
		ref Vector3	second,
		out float	result
	)			[static]

Calculates the angle (in radians) between two vectors.

Parameters:

	first	The first vector.
	second	The second vector.
	result	Angle (in radians) between the vectors.

Note that the returned angle is never bigger than the constant Pi.

Definition at line 1174 of file Vector3.cs.

        {
            float temp;
            Vector3.Dot(ref first, ref second, out temp);
            result = (float)System.Math.Acos(temp / (first.Length * second.Length));
        }

static float OpenTK.Vector3.CalculateAngle	(	Vector3	first,
		Vector3	second
	)			[static]

Calculates the angle (in radians) between two vectors.

Parameters:

	first	The first vector.
	second	The second vector.

Returns:

Angle (in radians) between the vectors.

Note that the returned angle is never bigger than the constant Pi.

Definition at line 1164 of file Vector3.cs.

        {
            return (float)System.Math.Acos((Vector3.Dot(first, second)) / (first.Length * second.Length));
        }

static void OpenTK.Vector3.Clamp	(	ref Vector3	vec,
		ref Vector3	min,
		ref Vector3	max,
		out Vector3	result
	)			[static]

Clamp a vector to the given minimum and maximum vectors.

Parameters:

	vec	Input vector
	min	Minimum vector
	max	Maximum vector
	result	The clamped vector

Definition at line 733 of file Vector3.cs.

        {
            result.X = vec.X < min.X ? min.X : vec.X > max.X ? max.X : vec.X;
            result.Y = vec.Y < min.Y ? min.Y : vec.Y > max.Y ? max.Y : vec.Y;
            result.Z = vec.Z < min.Z ? min.Z : vec.Z > max.Z ? max.Z : vec.Z;
        }

static Vector3 OpenTK.Vector3.Clamp	(	Vector3	vec,
		Vector3	min,
		Vector3	max
	)			[static]

Clamp a vector to the given minimum and maximum vectors.

Parameters:

	vec	Input vector
	min	Minimum vector
	max	Maximum vector

Returns:

The clamped vector

Definition at line 718 of file Vector3.cs.

        {
            vec.X = vec.X < min.X ? min.X : vec.X > max.X ? max.X : vec.X;
            vec.Y = vec.Y < min.Y ? min.Y : vec.Y > max.Y ? max.Y : vec.Y;
            vec.Z = vec.Z < min.Z ? min.Z : vec.Z > max.Z ? max.Z : vec.Z;
            return vec;
        }

static void OpenTK.Vector3.ComponentMax	(	ref Vector3	a,
		ref Vector3	b,
		out Vector3	result
	)			[static]

Calculate the component-wise maximum of two vectors.

Parameters:

	a	First operand
	b	Second operand
	result	The component-wise maximum

Definition at line 670 of file Vector3.cs.

        {
            result.X = a.X > b.X ? a.X : b.X;
            result.Y = a.Y > b.Y ? a.Y : b.Y;
            result.Z = a.Z > b.Z ? a.Z : b.Z;
        }

static Vector3 OpenTK.Vector3.ComponentMax	(	Vector3	a,
		Vector3	b
	)			[static]

Calculate the component-wise maximum of two vectors.

Parameters:

	a	First operand
	b	Second operand

Returns:

The component-wise maximum

Definition at line 656 of file Vector3.cs.

        {
            a.X = a.X > b.X ? a.X : b.X;
            a.Y = a.Y > b.Y ? a.Y : b.Y;
            a.Z = a.Z > b.Z ? a.Z : b.Z;
            return a;
        }

static void OpenTK.Vector3.ComponentMin	(	ref Vector3	a,
		ref Vector3	b,
		out Vector3	result
	)			[static]

Calculate the component-wise minimum of two vectors.

Parameters:

	a	First operand
	b	Second operand
	result	The component-wise minimum

Definition at line 639 of file Vector3.cs.

        {
            result.X = a.X < b.X ? a.X : b.X;
            result.Y = a.Y < b.Y ? a.Y : b.Y;
            result.Z = a.Z < b.Z ? a.Z : b.Z;
        }

static Vector3 OpenTK.Vector3.ComponentMin	(	Vector3	a,
		Vector3	b
	)			[static]

Calculate the component-wise minimum of two vectors.

Parameters:

	a	First operand
	b	Second operand

Returns:

The component-wise minimum

Definition at line 625 of file Vector3.cs.

        {
            a.X = a.X < b.X ? a.X : b.X;
            a.Y = a.Y < b.Y ? a.Y : b.Y;
            a.Z = a.Z < b.Z ? a.Z : b.Z;
            return a;
        }

static void OpenTK.Vector3.Cross	(	ref Vector3	left,
		ref Vector3	right,
		out Vector3	result
	)			[static]

Caclulate the cross (vector) product of two vectors.

Parameters:

	left	First operand
	right	Second operand

Returns:

The cross product of the two inputs

Parameters:

result

The cross product of the two inputs

Definition at line 852 of file Vector3.cs.

        {
            result = new Vector3(left.Y * right.Z - left.Z * right.Y,
                left.Z * right.X - left.X * right.Z,
                left.X * right.Y - left.Y * right.X);
        }

static Vector3 OpenTK.Vector3.Cross	(	Vector3	left,
		Vector3	right
	)			[static]

Caclulate the cross (vector) product of two vectors.

Parameters:

	left	First operand
	right	Second operand

Returns:

The cross product of the two inputs

Definition at line 838 of file Vector3.cs.

        {
            Vector3 result;
            Cross(ref left, ref right, out result);
            return result;
        }

static void OpenTK.Vector3.Div	(	ref Vector3	a,
		float	f,
		out Vector3	result
	)			[static]

Divide a vector by a scalar.

Parameters:

	a	Vector operand
	f	Scalar operand
	result	Result of the division

Definition at line 451 of file Vector3.cs.

        {
            float mult = 1.0f / f;
            result.X = a.X * mult;
            result.Y = a.Y * mult;
            result.Z = a.Z * mult;
        }

static Vector3 OpenTK.Vector3.Div	(	Vector3	a,
		float	f
	)			[static]

Divide a vector by a scalar.

Parameters:

	a	Vector operand
	f	Scalar operand

Returns:

Result of the division

Definition at line 435 of file Vector3.cs.

        {
            float mult = 1.0f / f;
            a.X *= mult;
            a.Y *= mult;
            a.Z *= mult;
            return a;
        }

void OpenTK.Vector3.Div

(

float

f

)

Divide this instance by a scalar.

Parameters:

f

Scalar operand.

Definition at line 182 of file Vector3.cs.

        {
            float mult = 1.0f / f;
            this.X *= mult;
            this.Y *= mult;
            this.Z *= mult;
        }

static void OpenTK.Vector3.Divide	(	ref Vector3	vector,
		ref Vector3	scale,
		out Vector3	result
	)			[static]

Divide a vector by the components of a vector (scale).

Parameters:

	vector	Left operand.
	scale	Right operand.
	result	Result of the operation.

Definition at line 610 of file Vector3.cs.

        {
            result = new Vector3(vector.X / scale.X, vector.Y / scale.Y, vector.Z / scale.Z);
        }

static Vector3 OpenTK.Vector3.Divide	(	Vector3	vector,
		Vector3	scale
	)			[static]

Divides a vector by the components of a vector (scale).

Parameters:

	vector	Left operand.
	scale	Right operand.

Returns:

Result of the operation.

Definition at line 598 of file Vector3.cs.

        {
            Divide(ref vector, ref scale, out vector);
            return vector;
        }

static void OpenTK.Vector3.Divide	(	ref Vector3	vector,
		float	scale,
		out Vector3	result
	)			[static]

Divides a vector by a scalar.

Parameters:

	vector	Left operand.
	scale	Right operand.
	result	Result of the operation.

Definition at line 587 of file Vector3.cs.

        {
            Multiply(ref vector, 1 / scale, out result);
        }

static Vector3 OpenTK.Vector3.Divide	(	Vector3	vector,
		float	scale
	)			[static]

Divides a vector by a scalar.

Parameters:

	vector	Left operand.
	scale	Right operand.

Returns:

Result of the operation.

Definition at line 575 of file Vector3.cs.

        {
            Divide(ref vector, scale, out vector);
            return vector;
        }

static void OpenTK.Vector3.Dot	(	ref Vector3	left,
		ref Vector3	right,
		out float	result
	)			[static]

Calculate the dot (scalar) product of two vectors.

Parameters:

	left	First operand
	right	Second operand
	result	The dot product of the two inputs

Definition at line 823 of file Vector3.cs.

        {
            result = left.X * right.X + left.Y * right.Y + left.Z * right.Z;
        }

static float OpenTK.Vector3.Dot	(	Vector3	left,
		Vector3	right
	)			[static]

Calculate the dot (scalar) product of two vectors.

Parameters:

	left	First operand
	right	Second operand

Returns:

The dot product of the two inputs

Definition at line 812 of file Vector3.cs.

        {
            return left.X * right.X + left.Y * right.Y + left.Z * right.Z;
        }

bool OpenTK.Vector3.Equals

(

Vector3

other

)

Indicates whether the current vector is equal to another vector.

Parameters:

other

A vector to compare with this vector.

Returns:

true if the current vector is equal to the vector parameter; otherwise, false.

Definition at line 1359 of file Vector3.cs.

        {
            return
                X == other.X &&
                Y == other.Y &&
                Z == other.Z;
        }

override bool OpenTK.Vector3.Equals

(

object

obj

)

Indicates whether this instance and a specified object are equal.

Parameters:

obj

The object to compare to.

Returns:

True if the instances are equal; false otherwise.

Definition at line 1340 of file Vector3.cs.

        {
            if (!(obj is Vector3))
                return false;

            return this.Equals((Vector3)obj);
        }

override int OpenTK.Vector3.GetHashCode

(

)

Returns the hashcode for this instance.

Returns:

A System.Int32 containing the unique hashcode for this instance.

Definition at line 1326 of file Vector3.cs.

        {
            return X.GetHashCode() ^ Y.GetHashCode() ^ Z.GetHashCode();
        }

static void OpenTK.Vector3.Lerp	(	ref Vector3	a,
		ref Vector3	b,
		float	blend,
		out Vector3	result
	)			[static]

Returns a new Vector that is the linear blend of the 2 given Vectors.

Parameters:

	a	First input vector
	b	Second input vector
	blend	The blend factor. a when blend=0, b when blend=1.
	result	a when blend=0, b when blend=1, and a linear combination otherwise

Definition at line 885 of file Vector3.cs.

        {
            result.X = blend * (b.X - a.X) + a.X;
            result.Y = blend * (b.Y - a.Y) + a.Y;
            result.Z = blend * (b.Z - a.Z) + a.Z;
        }

static Vector3 OpenTK.Vector3.Lerp	(	Vector3	a,
		Vector3	b,
		float	blend
	)			[static]

Returns a new Vector that is the linear blend of the 2 given Vectors.

Parameters:

	a	First input vector
	b	Second input vector
	blend	The blend factor. a when blend=0, b when blend=1.

Returns:

a when blend=0, b when blend=1, and a linear combination otherwise

Definition at line 870 of file Vector3.cs.

        {
            a.X = blend * (b.X - a.X) + a.X;
            a.Y = blend * (b.Y - a.Y) + a.Y;
            a.Z = blend * (b.Z - a.Z) + a.Z;
            return a;
        }

static Vector3 OpenTK.Vector3.Max	(	Vector3	left,
		Vector3	right
	)			[static]

Returns the Vector3 with the minimum magnitude.

Parameters:

	left	Left operand
	right	Right operand

Returns:

The minimum Vector3

Definition at line 702 of file Vector3.cs.

        {
            return left.LengthSquared >= right.LengthSquared ? left : right;
        }

static Vector3 OpenTK.Vector3.Min	(	Vector3	left,
		Vector3	right
	)			[static]

Returns the Vector3 with the minimum magnitude.

Parameters:

	left	Left operand
	right	Right operand

Returns:

The minimum Vector3

Definition at line 687 of file Vector3.cs.

        {
            return left.LengthSquared < right.LengthSquared ? left : right;
        }

static void OpenTK.Vector3.Mult	(	ref Vector3	a,
		float	f,
		out Vector3	result
	)			[static]

Multiply a vector and a scalar.

Parameters:

	a	Vector operand
	f	Scalar operand
	result	Result of the multiplication

Definition at line 417 of file Vector3.cs.

        {
            result.X = a.X * f;
            result.Y = a.Y * f;
            result.Z = a.Z * f;
        }

static Vector3 OpenTK.Vector3.Mult	(	Vector3	a,
		float	f
	)			[static]

Multiply a vector and a scalar.

Parameters:

	a	Vector operand
	f	Scalar operand

Returns:

Result of the multiplication

Definition at line 402 of file Vector3.cs.

        {
            a.X *= f;
            a.Y *= f;
            a.Z *= f;
            return a;
        }

void OpenTK.Vector3.Mult

(

float

f

)

Multiply this instance by a scalar.

Parameters:

f

Scalar operand.

Definition at line 168 of file Vector3.cs.

        {
            this.X *= f;
            this.Y *= f;
            this.Z *= f;
        }

static void OpenTK.Vector3.Multiply	(	ref Vector3	vector,
		ref Vector3	scale,
		out Vector3	result
	)			[static]

Multiplies a vector by the components of a vector (scale).

Parameters:

	vector	Left operand.
	scale	Right operand.
	result	Result of the operation.

Definition at line 560 of file Vector3.cs.

        {
            result = new Vector3(vector.X * scale.X, vector.Y * scale.Y, vector.Z * scale.Z);
        }

static Vector3 OpenTK.Vector3.Multiply	(	Vector3	vector,
		Vector3	scale
	)			[static]

Multiplies a vector by the components a vector (scale).

Parameters:

	vector	Left operand.
	scale	Right operand.

Returns:

Result of the operation.

Definition at line 548 of file Vector3.cs.

        {
            Multiply(ref vector, ref scale, out vector);
            return vector;
        }

static void OpenTK.Vector3.Multiply	(	ref Vector3	vector,
		float	scale,
		out Vector3	result
	)			[static]

Multiplies a vector by a scalar.

Parameters:

	vector	Left operand.
	scale	Right operand.
	result	Result of the operation.

Definition at line 537 of file Vector3.cs.

        {
            result = new Vector3(vector.X * scale, vector.Y * scale, vector.Z * scale);
        }

static Vector3 OpenTK.Vector3.Multiply	(	Vector3	vector,
		float	scale
	)			[static]

Multiplies a vector by a scalar.

Parameters:

	vector	Left operand.
	scale	Right operand.

Returns:

Result of the operation.

Definition at line 525 of file Vector3.cs.

        {
            Multiply(ref vector, scale, out vector);
            return vector;
        }

static void OpenTK.Vector3.Normalize	(	ref Vector3	vec,
		out Vector3	result
	)			[static]

Scale a vector to unit length.

Parameters:

	vec	The input vector
	result	The normalized vector

Definition at line 763 of file Vector3.cs.

        {
            float scale = 1.0f / vec.Length;
            result.X = vec.X * scale;
            result.Y = vec.Y * scale;
            result.Z = vec.Z * scale;
        }

static Vector3 OpenTK.Vector3.Normalize

(

Vector3

vec

)

[static]

Scale a vector to unit length.

Parameters:

vec

The input vector

Returns:

The normalized vector

Definition at line 749 of file Vector3.cs.

        {
            float scale = 1.0f / vec.Length;
            vec.X *= scale;
            vec.Y *= scale;
            vec.Z *= scale;
            return vec;
        }

void OpenTK.Vector3.Normalize

(

)

Scales the Vector3 to unit length.

Definition at line 256 of file Vector3.cs.

        {
            float scale = 1.0f / this.Length;
            X *= scale;
            Y *= scale;
            Z *= scale;
        }

static void OpenTK.Vector3.NormalizeFast	(	ref Vector3	vec,
		out Vector3	result
	)			[static]

Scale a vector to approximately unit length.

Parameters:

	vec	The input vector
	result	The normalized vector

Definition at line 794 of file Vector3.cs.

        {
            float scale = MathHelper.InverseSqrtFast(vec.X * vec.X + vec.Y * vec.Y + vec.Z * vec.Z);
            result.X = vec.X * scale;
            result.Y = vec.Y * scale;
            result.Z = vec.Z * scale;
        }

static Vector3 OpenTK.Vector3.NormalizeFast

(

Vector3

vec

)

[static]

Scale a vector to approximately unit length.

Parameters:

vec

The input vector

Returns:

The normalized vector

Definition at line 780 of file Vector3.cs.

        {
            float scale = MathHelper.InverseSqrtFast(vec.X * vec.X + vec.Y * vec.Y + vec.Z * vec.Z);
            vec.X *= scale;
            vec.Y *= scale;
            vec.Z *= scale;
            return vec;
        }

void OpenTK.Vector3.NormalizeFast

(

)

Scales the Vector3 to approximately unit length.

Definition at line 271 of file Vector3.cs.

        {
            float scale = MathHelper.InverseSqrtFast(X * X + Y * Y + Z * Z);
            X *= scale;
            Y *= scale;
            Z *= scale;
        }

static bool OpenTK.Vector3.operator!=	(	Vector3	left,
		Vector3	right
	)			[static]

Compares two instances for inequality.

Parameters:

	left	The first instance.
	right	The second instance.

Returns:

True, if left does not equa lright; false otherwise.

Definition at line 1298 of file Vector3.cs.

        {
            return !left.Equals(right);
        }

static Vector3 OpenTK.Vector3.operator*	(	float	scale,
		Vector3	vec
	)			[static]

Multiplies an instance by a scalar.

Parameters:

	scale	The scalar.
	vec	The instance.

Returns:

The result of the calculation.

Definition at line 1258 of file Vector3.cs.

        {
            vec.X *= scale;
            vec.Y *= scale;
            vec.Z *= scale;
            return vec;
        }

static Vector3 OpenTK.Vector3.operator*	(	Vector3	vec,
		float	scale
	)			[static]

Multiplies an instance by a scalar.

Parameters:

	vec	The instance.
	scale	The scalar.

Returns:

The result of the calculation.

Definition at line 1244 of file Vector3.cs.

        {
            vec.X *= scale;
            vec.Y *= scale;
            vec.Z *= scale;
            return vec;
        }

static Vector3 OpenTK.Vector3.operator+	(	Vector3	left,
		Vector3	right
	)			[static]

Adds two instances.

Parameters:

	left	The first instance.
	right	The second instance.

Returns:

The result of the calculation.

Definition at line 1203 of file Vector3.cs.

        {
            left.X += right.X;
            left.Y += right.Y;
            left.Z += right.Z;
            return left;
        }

static Vector3 OpenTK.Vector3.operator-

(

Vector3

vec

)

[static]

Negates an instance.

Parameters:

vec

The instance.

Returns:

The result of the calculation.

Definition at line 1230 of file Vector3.cs.

        {
            vec.X = -vec.X;
            vec.Y = -vec.Y;
            vec.Z = -vec.Z;
            return vec;
        }

static Vector3 OpenTK.Vector3.operator-	(	Vector3	left,
		Vector3	right
	)			[static]

Subtracts two instances.

Parameters:

	left	The first instance.
	right	The second instance.

Returns:

The result of the calculation.

Definition at line 1217 of file Vector3.cs.

        {
            left.X -= right.X;
            left.Y -= right.Y;
            left.Z -= right.Z;
            return left;
        }

static Vector3 OpenTK.Vector3.operator/	(	Vector3	vec,
		float	scale
	)			[static]

Divides an instance by a scalar.

Parameters:

	vec	The instance.
	scale	The scalar.

Returns:

The result of the calculation.

Definition at line 1272 of file Vector3.cs.

        {
            float mult = 1.0f / scale;
            vec.X *= mult;
            vec.Y *= mult;
            vec.Z *= mult;
            return vec;
        }

static bool OpenTK.Vector3.operator==	(	Vector3	left,
		Vector3	right
	)			[static]

Compares two instances for equality.

Parameters:

	left	The first instance.
	right	The second instance.

Returns:

True, if left equals right; false otherwise.

Definition at line 1287 of file Vector3.cs.

        {
            return left.Equals(right);
        }

void OpenTK.Vector3.Scale

(

ref Vector3

scale

)

Scales this instance by the given parameter.

Parameters:

scale

The scaling of the individual components.

Definition at line 311 of file Vector3.cs.

        {
            this.X *= scale.X;
            this.Y *= scale.Y;
            this.Z *= scale.Z;
        }

void OpenTK.Vector3.Scale

(

Vector3

scale

)

Scales this instance by the given parameter.

Parameters:

scale

The scaling of the individual components.

Definition at line 300 of file Vector3.cs.

        {
            this.X *= scale.X;
            this.Y *= scale.Y;
            this.Z *= scale.Z;
        }

void OpenTK.Vector3.Scale	(	float	sx,
		float	sy,
		float	sz
	)

Scales the current Vector3 by the given amounts.

Parameters:

	sx	The scale of the X component.
	sy	The scale of the Y component.
	sz	The scale of the Z component.

Definition at line 290 of file Vector3.cs.

        {
            this.X = X * sx;
            this.Y = Y * sy;
            this.Z = Z * sz;
        }

static void OpenTK.Vector3.Sub	(	ref Vector3	a,
		ref Vector3	b,
		out Vector3	result
	)			[static]

Subtract one Vector from another.

Parameters:

	a	First operand
	b	Second operand
	result	Result of subtraction

Definition at line 384 of file Vector3.cs.

        {
            result.X = a.X - b.X;
            result.Y = a.Y - b.Y;
            result.Z = a.Z - b.Z;
        }

static Vector3 OpenTK.Vector3.Sub	(	Vector3	a,
		Vector3	b
	)			[static]

Subtract one Vector from another.

Parameters:

	a	First operand
	b	Second operand

Returns:

Result of subtraction

Definition at line 369 of file Vector3.cs.

        {
            a.X -= b.X;
            a.Y -= b.Y;
            a.Z -= b.Z;
            return a;
        }

void OpenTK.Vector3.Sub

(

ref Vector3

right

)

Subtract the Vector passed as parameter from this instance.

Parameters:

right

Right operand. This parameter is only read from.

Definition at line 154 of file Vector3.cs.

        {
            this.X -= right.X;
            this.Y -= right.Y;
            this.Z -= right.Z;
        }

void OpenTK.Vector3.Sub

(

Vector3

right

)

Subtract the Vector passed as parameter from this instance.

Parameters:

right

Right operand. This parameter is only read from.

Definition at line 143 of file Vector3.cs.

        {
            this.X -= right.X;
            this.Y -= right.Y;
            this.Z -= right.Z;
        }

static void OpenTK.Vector3.Subtract	(	ref Vector3	a,
		ref Vector3	b,
		out Vector3	result
	)			[static]

Subtract one Vector from another.

Parameters:

	a	First operand
	b	Second operand
	result	Result of subtraction

Definition at line 510 of file Vector3.cs.

        {
            result = new Vector3(a.X - b.X, a.Y - b.Y, a.Z - b.Z);
        }

static Vector3 OpenTK.Vector3.Subtract	(	Vector3	a,
		Vector3	b
	)			[static]

Subtract one Vector from another.

Parameters:

	a	First operand
	b	Second operand

Returns:

Result of subtraction

Definition at line 498 of file Vector3.cs.

        {
            Subtract(ref a, ref b, out a);
            return a;
        }

override string OpenTK.Vector3.ToString

(

)

Returns a System.String that represents the current Vector3.

Returns:

Definition at line 1313 of file Vector3.cs.

        {
            return String.Format("({0}, {1}, {2})", X, Y, Z);
        }

static void OpenTK.Vector3.Transform	(	ref Vector3	vec,
		ref Quaternion	quat,
		out Vector3	result
	)			[static]

Transforms a vector by a quaternion rotation.

Parameters:

	vec	The vector to transform.
	quat	The quaternion to rotate the vector by.
	result	The result of the operation.

Definition at line 1116 of file Vector3.cs.

        {
            // Since vec.W == 0, we can optimize quat * vec * quat^-1 as follows:
            // vec + 2.0 * cross(quat.xyz, cross(quat.xyz, vec) + quat.w * vec)
            Vector3 xyz = quat.Xyz, temp, temp2;
            Vector3.Cross(ref xyz, ref vec, out temp);
            Vector3.Multiply(ref vec, quat.W, out temp2);
            Vector3.Add(ref temp, ref temp2, out temp);
            Vector3.Cross(ref xyz, ref temp, out temp);
            Vector3.Multiply(ref temp, 2, out temp);
            Vector3.Add(ref vec, ref temp, out result);
        }

static Vector3 OpenTK.Vector3.Transform	(	Vector3	vec,
		Quaternion	quat
	)			[static]

Transforms a vector by a quaternion rotation.

Parameters:

	vec	The vector to transform.
	quat	The quaternion to rotate the vector by.

Returns:

The result of the operation.

Definition at line 1103 of file Vector3.cs.

        {
            Vector3 result;
            Transform(ref vec, ref quat, out result);
            return result;
        }

static void OpenTK.Vector3.Transform	(	ref Vector3	vec,
		ref Matrix4	mat,
		out Vector3	result
	)			[static]

Transform a Vector by the given Matrix.

Parameters:

	vec	The vector to transform
	mat	The desired transformation
	result	The transformed vector

Definition at line 1090 of file Vector3.cs.

        {
            Vector4 v4 = new Vector4(vec.X, vec.Y, vec.Z, 1.0f);
            Vector4.Transform(ref v4, ref mat, out v4);
            result = v4.Xyz;
        }

static Vector3 OpenTK.Vector3.Transform	(	Vector3	vec,
		Matrix4	mat
	)			[static]

Transform a Vector by the given Matrix.

Parameters:

	vec	The vector to transform
	mat	The desired transformation

Returns:

The transformed vector

Definition at line 1079 of file Vector3.cs.

        {
            Vector3 result;
            Transform(ref vec, ref mat, out result);
            return result;
        }

static void OpenTK.Vector3.TransformNormal	(	ref Vector3	norm,
		ref Matrix4	mat,
		out Vector3	result
	)			[static]

Transform a Normal by the given Matrix.

This calculates the inverse of the given matrix, use TransformNormalInverse if you already have the inverse to avoid this extra calculation

Parameters:

	norm	The normal to transform
	mat	The desired transformation
	result	The transformed normal

Definition at line 994 of file Vector3.cs.

        {
            Matrix4 Inverse = Matrix4.Invert(mat);
            Vector3.TransformNormalInverse(ref norm, ref Inverse, out result);
        }

static Vector3 OpenTK.Vector3.TransformNormal	(	Vector3	norm,
		Matrix4	mat
	)			[static]

Transform a Normal by the given Matrix.

This calculates the inverse of the given matrix, use TransformNormalInverse if you already have the inverse to avoid this extra calculation

Parameters:

	norm	The normal to transform
	mat	The desired transformation

Returns:

The transformed normal

Definition at line 980 of file Vector3.cs.

        {
            mat.Invert();
            return TransformNormalInverse(norm, mat);
        }

static void OpenTK.Vector3.TransformNormalInverse	(	ref Vector3	norm,
		ref Matrix4	invMat,
		out Vector3	result
	)			[static]

Transform a Normal by the (transpose of the) given Matrix.

This version doesn't calculate the inverse matrix. Use this version if you already have the inverse of the desired transform to hand

Parameters:

	norm	The normal to transform
	invMat	The inverse of the desired transformation
	result	The transformed normal

Definition at line 1025 of file Vector3.cs.

        {
            result.X = norm.X * invMat.Row0.X +
                       norm.Y * invMat.Row0.Y +
                       norm.Z * invMat.Row0.Z;

            result.Y = norm.X * invMat.Row1.X +
                       norm.Y * invMat.Row1.Y +
                       norm.Z * invMat.Row1.Z;

            result.Z = norm.X * invMat.Row2.X +
                       norm.Y * invMat.Row2.Y +
                       norm.Z * invMat.Row2.Z;
        }

static Vector3 OpenTK.Vector3.TransformNormalInverse	(	Vector3	norm,
		Matrix4	invMat
	)			[static]

Transform a Normal by the (transpose of the) given Matrix.

This version doesn't calculate the inverse matrix. Use this version if you already have the inverse of the desired transform to hand

Parameters:

	norm	The normal to transform
	invMat	The inverse of the desired transformation

Returns:

The transformed normal

Definition at line 1008 of file Vector3.cs.

        {
            Vector3 n;
            n.X = Vector3.Dot(norm, new Vector3(invMat.Row0));
            n.Y = Vector3.Dot(norm, new Vector3(invMat.Row1));
            n.Z = Vector3.Dot(norm, new Vector3(invMat.Row2));
            return n;
        }

static void OpenTK.Vector3.TransformPerspective	(	ref Vector3	vec,
		ref Matrix4	mat,
		out Vector3	result
	)			[static]

Transform a Vector3 by the given Matrix, and project the resulting Vector4 back to a Vector3.

Parameters:

	vec	The vector to transform
	mat	The desired transformation
	result	The transformed vector

Definition at line 1144 of file Vector3.cs.

        {
            Vector4 v = new Vector4(vec);
            Vector4.Transform(ref v, ref mat, out v);
            result.X = v.X / v.W;
            result.Y = v.Y / v.W;
            result.Z = v.Z / v.W;
        }

static Vector3 OpenTK.Vector3.TransformPerspective	(	Vector3	vec,
		Matrix4	mat
	)			[static]

Transform a Vector3 by the given Matrix, and project the resulting Vector4 back to a Vector3.

Parameters:

	vec	The vector to transform
	mat	The desired transformation

Returns:

The transformed vector

Definition at line 1133 of file Vector3.cs.

        {
            Vector3 result;
            TransformPerspective(ref vec, ref mat, out result);
            return result;
        }

static void OpenTK.Vector3.TransformPosition	(	ref Vector3	pos,
		ref Matrix4	mat,
		out Vector3	result
	)			[static]

Transform a Position by the given Matrix.

Parameters:

	pos	The position to transform
	mat	The desired transformation
	result	The transformed position

Definition at line 1057 of file Vector3.cs.

        {
            result.X = pos.X * mat.Row0.X +
                       pos.Y * mat.Row1.X +
                       pos.Z * mat.Row2.X +
                       mat.Row3.X;

            result.Y = pos.X * mat.Row0.Y +
                       pos.Y * mat.Row1.Y +
                       pos.Z * mat.Row2.Y +
                       mat.Row3.Y;

            result.Z = pos.X * mat.Row0.Z +
                       pos.Y * mat.Row1.Z +
                       pos.Z * mat.Row2.Z +
                       mat.Row3.Z;
        }

static Vector3 OpenTK.Vector3.TransformPosition	(	Vector3	pos,
		Matrix4	mat
	)			[static]

Transform a Position by the given Matrix.

Parameters:

	pos	The position to transform
	mat	The desired transformation

Returns:

The transformed position

Definition at line 1044 of file Vector3.cs.

        {
            Vector3 p;
            p.X = Vector3.Dot(pos, new Vector3(mat.Column0)) + mat.Row3.X;
            p.Y = Vector3.Dot(pos, new Vector3(mat.Column1)) + mat.Row3.Y;
            p.Z = Vector3.Dot(pos, new Vector3(mat.Column2)) + mat.Row3.Z;
            return p;
        }

static void OpenTK.Vector3.TransformVector	(	ref Vector3	vec,
		ref Matrix4	mat,
		out Vector3	result
	)			[static]

Transform a direction vector by the given Matrix Assumes the matrix has a bottom row of (0,0,0,1), that is the translation part is ignored.

Parameters:

	vec	The vector to transform
	mat	The desired transformation
	result	The transformed vector

Definition at line 957 of file Vector3.cs.

        {
            result.X = vec.X * mat.Row0.X +
                       vec.Y * mat.Row1.X +
                       vec.Z * mat.Row2.X;

            result.Y = vec.X * mat.Row0.Y +
                       vec.Y * mat.Row1.Y +
                       vec.Z * mat.Row2.Y;

            result.Z = vec.X * mat.Row0.Z +
                       vec.Y * mat.Row1.Z +
                       vec.Z * mat.Row2.Z;
        }

static Vector3 OpenTK.Vector3.TransformVector	(	Vector3	vec,
		Matrix4	mat
	)			[static]

Transform a direction vector by the given Matrix Assumes the matrix has a bottom row of (0,0,0,1), that is the translation part is ignored.

Parameters:

	vec	The vector to transform
	mat	The desired transformation

Returns:

The transformed vector

Definition at line 942 of file Vector3.cs.

        {
            Vector3 v;
            v.X = Vector3.Dot(vec, new Vector3(mat.Column0));
            v.Y = Vector3.Dot(vec, new Vector3(mat.Column1));
            v.Z = Vector3.Dot(vec, new Vector3(mat.Column2));
            return v;
        }

---

Member Data Documentation

readonly Vector3 OpenTK.Vector3.One = new Vector3(1, 1, 1) [static]

Defines an instance with all components set to 1.

Definition at line 349 of file Vector3.cs.

readonly int OpenTK.Vector3.SizeInBytes = Marshal.SizeOf(new Vector3()) [static]

Defines the size of the Vector3 struct in bytes.

Definition at line 354 of file Vector3.cs.

readonly Vector3 OpenTK.Vector3.UnitX = new Vector3(1, 0, 0) [static]

Defines a unit-length Vector3 that points towards the X-axis.

Definition at line 329 of file Vector3.cs.

readonly Vector3 OpenTK.Vector3.UnitY = new Vector3(0, 1, 0) [static]

Defines a unit-length Vector3 that points towards the Y-axis.

Definition at line 334 of file Vector3.cs.

readonly Vector3 OpenTK.Vector3.UnitZ = new Vector3(0, 0, 1) [static]

/ Defines a unit-length Vector3 that points towards the Z-axis.

Definition at line 339 of file Vector3.cs.

float OpenTK.Vector3.X

The X component of the Vector3.

Definition at line 45 of file Vector3.cs.

float OpenTK.Vector3.Y

The Y component of the Vector3.

Definition at line 50 of file Vector3.cs.

float OpenTK.Vector3.Z

The Z component of the Vector3.

Definition at line 55 of file Vector3.cs.

readonly Vector3 OpenTK.Vector3.Zero = new Vector3(0, 0, 0) [static]

Defines a zero-length Vector3.

Definition at line 344 of file Vector3.cs.

---

Property Documentation

float OpenTK.Vector3.Length [get]

Gets the length (magnitude) of the vector.

LengthFast

See also:

LengthSquared

Definition at line 200 of file Vector3.cs.

float OpenTK.Vector3.LengthFast [get]

Gets an approximation of the vector length (magnitude).

This property uses an approximation of the square root function to calculate vector magnitude, with an upper error bound of 0.001.

Length

See also:

LengthSquared

Definition at line 221 of file Vector3.cs.

float OpenTK.Vector3.LengthSquared [get]

Gets the square of the vector length (magnitude).

This property avoids the costly square root operation required by the Length property. This makes it more suitable for comparisons.

Length

See also:

LengthFast

Definition at line 242 of file Vector3.cs.

Vector2 OpenTK.Vector3.Xy [get, set]

Gets or sets an OpenTK.Vector2 with the X and Y components of this instance.

Definition at line 1191 of file Vector3.cs.