com.io7m.jtensors

Class QuaternionM4F

java.lang.Object

com.io7m.jtensors.QuaternionM4F

All Implemented Interfaces:

Quaternion4FType, QuaternionReadable4FType, QuaternionWritable4FType, Vector2FType, Vector3FType, Vector4FType, VectorReadable2FType, VectorReadable3FType, VectorReadable4FType, VectorWritable2FType, VectorWritable3FType, VectorWritable4FType

public final class QuaternionM4F
extends Object
implements Quaternion4FType

A four-dimensional mutable quaternion type with float elements.

Values of this type cannot be accessed safely from multiple threads without explicit synchronization.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	QuaternionM4F.ContextQM4F The ContextQM4F type contains the minimum storage required for all of the functions of the QuaternionM4D class.

Constructor Summary

Constructors

Constructor and Description
QuaternionM4F() Default constructor, initializing the quaternion with values [0.0, 0.0, 0.0, 1.0]
QuaternionM4F(float in_x, float in_y, float in_z, float in_w) Construct a quaternion initialized with the given values.
QuaternionM4F(QuaternionReadable4FType q) Construct a quaternion initialized with the values given in q.

Method Summary

Modifier and Type	Method and Description
static <Q extends QuaternionWritable4FType> Q	add(QuaternionReadable4FType q0, QuaternionReadable4FType q1, Q out) Calculate the element-wise sum of the quaternions q0 and q1, saving the result to qr.
static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q	addInPlace(Q q0, QuaternionReadable4FType q1) Calculate the element-wise sum of the quaternions q0 and q1, saving the result to q0.
static boolean	almostEqual(com.io7m.jequality.AlmostEqualFloat.ContextRelative context, QuaternionReadable4FType qa, QuaternionReadable4FType qb) Determine whether or not the quaternions qa and qb are equal to within the degree of error given in context.
static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q	conjugate(QuaternionReadable4FType q, Q out) Calculate the conjugate of the input quaternion q, saving the result to out.
static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q	conjugateInPlace(Q q) Calculate the conjugate of the input quaternion q, modifying q in place.
static <Q extends QuaternionWritable4FType> Q	copy(QuaternionReadable4FType q, Q out) Copy the contents of the quaternion q to out.
void	copyFrom2F(VectorReadable2FType in_v) Set the current vector to the contents of the input vector.
void	copyFrom3F(VectorReadable3FType in_v) Set the current vector to the contents of the input vector.
void	copyFrom4F(VectorReadable4FType in_v) Set the current vector to the contents of the input vector.
static double	dotProduct(QuaternionReadable4FType q0, QuaternionReadable4FType q1) Calculate the scalar product of the quaternions q0 and q1.
boolean	equals(Object obj)
float	getWF()
float	getXF()
float	getYF()
float	getZF()
int	hashCode()
static <Q extends QuaternionWritable4FType> Q	interpolateLinear(QuaternionM4F.ContextQM4F c, QuaternionReadable4FType q0, QuaternionReadable4FType q1, double alpha, Q r) Linearly interpolate between q0 and q1 by the amount alpha, such that: interpolateLinear(q0, q1, 0.0, r) -> r = q0 interpolateLinear(q0, q1, 1.0, r) -> r = q1
static <Q extends QuaternionWritable4FType> Q	interpolateSphericalLinear(QuaternionM4F.ContextQM4F c, QuaternionReadable4FType q0, QuaternionReadable4FType q1, float alpha, Q r) Linearly interpolate between q0 and q1 by the amount alpha, such that: interpolateSphericalLinear(q0, q1, 0.0, r) -> r = q0 interpolateSphericalLinear(q0, q1, 1.0, r) -> r = q1
static boolean	isNegationOf(com.io7m.jequality.AlmostEqualFloat.ContextRelative context, QuaternionReadable4FType qa, QuaternionReadable4FType qb) Return true iff qa is the negation of qb.
static <Q extends QuaternionWritable4FType> Q	lookAt(QuaternionM4F.ContextQM4F context, VectorReadable3FType origin, VectorReadable3FType target, VectorReadable3FType up, Q q) Produce a quaternion that represents a rotation that "looks at" the point at target assuming the viewer is at origin, using up as the "up" vector, saving the result to q.
static double	magnitude(QuaternionReadable4FType q) Calculate the magnitude of the quaternion q.
static double	magnitudeSquared(QuaternionReadable4FType q) Calculate the squared magnitude of the quaternion q.
static <Q extends QuaternionWritable4FType> Q	makeFromAxisAngle(VectorReadable3FType axis, double angle, Q out) Produce a quaternion that represents a rotation of angle degrees around the axis specified by axis, saving the result to out.
static <Q extends QuaternionWritable4FType> Q	makeFromRotationMatrix3x3(MatrixReadable3x3FType m, Q out) Produce a quaternion equivalent to the rotation matrix m, writing the result to out.
static <Q extends QuaternionWritable4FType> Q	makeFromRotationMatrix4x4(MatrixReadable4x4FType m, Q out) Produce a quaternion equivalent to the rotation matrix m, writing the result to out.
static <M extends MatrixWritable3x3FType> M	makeRotationMatrix3x3(QuaternionReadable4FType q, M m) Produce a rotation matrix from the quaternion q, saving the result to m.
static <M extends MatrixWritable4x4FType> M	makeRotationMatrix4x4(QuaternionReadable4FType q, M m) Produce a rotation matrix from the quaternion q, saving the result to m.
static <Q extends QuaternionWritable4FType> Q	multiply(QuaternionReadable4FType q0, QuaternionReadable4FType q1, Q qr) Multiply the quaternion q0 by the quaternion q1 , saving the result to qr.
static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q	multiplyInPlace(Q q0, QuaternionReadable4FType q1) Multiply the quaternion q0 by the quaternion q1 , saving the result to q0.
static <Q extends QuaternionWritable4FType> Q	negate(QuaternionReadable4FType qa, Q out) Negate the elements of qa, writing the resulting quaternion to out.
static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q	negateInPlace(Q q) Negate the elements of q, modifying the quaternion in-place.
static <Q extends QuaternionWritable4FType> Q	normalize(QuaternionReadable4FType q, Q out) Returns a quaternion with the same orientation as q but with magnitude equal to 1.0 in out.
static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q	normalizeInPlace(Q q) Returns a quaternion with the same orientation as q but with magnitude equal to 1.0 in q.
static <Q extends QuaternionWritable4FType> Q	scale(QuaternionReadable4FType q, double r, Q out) Scale the quaternion q by the scalar r, saving the result to out.
static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q	scaleInPlace(Q q, double r) Scale the quaternion q by the scalar r, saving the result to q.
void	set2F(float in_x, float in_y) Set the current x and y values of the current vector.
void	set3F(float in_x, float in_y, float in_z) Set the current x, y and z values of the current vector.
void	set4F(float in_x, float in_y, float in_z, float in_w) Set the current x, y, z and w values of the current vector.
void	setWF(float in_w) Set the current w value of the current vector.
void	setXF(float in_x) Set the current x value of the current vector.
void	setYF(float in_y) Set the current y value of the current vector.
void	setZF(float in_z) Set the current z value of the current vector.
static <Q extends QuaternionWritable4FType> Q	subtract(QuaternionReadable4FType q0, QuaternionReadable4FType q1, Q out) Subtract the quaternion q0 from the quaternion q1, saving the result to out.
static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q	subtractInPlace(Q q0, QuaternionReadable4FType q1) Subtract the quaternion q0 from the quaternion q1, saving the result to q0.
static <V extends VectorWritable3FType> double	toAxisAngle(QuaternionReadable4FType q, V out) Determine the axis-angle representation of the given quaternion.
String	toString()

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

QuaternionM4F

public QuaternionM4F()

Default constructor, initializing the quaternion with values [0.0, 0.0, 0.0, 1.0]

QuaternionM4F

public QuaternionM4F(float in_x,
                     float in_y,
                     float in_z,
                     float in_w)

Construct a quaternion initialized with the given values.

Parameters:

in_x - The x value

in_y - The y value

in_z - The z value

in_w - The w value

QuaternionM4F

public QuaternionM4F(QuaternionReadable4FType q)

Construct a quaternion initialized with the values given in q.

Parameters:

q - The source quaternion

Method Detail

add

public static <Q extends QuaternionWritable4FType> Q add(QuaternionReadable4FType q0,
                                                         QuaternionReadable4FType q1,
                                                         Q out)

Calculate the element-wise sum of the quaternions q0 and q1, saving the result to qr.

Type Parameters:

Q - The precise type of quaternion

Parameters:

q0 - The left input quaternion

q1 - The right input quaternion

out - The output quaternion

Returns:

(q0.x + q1.x, q0.y + q1.y, q0.z + q1.z, q0.w + q1.w)

addInPlace

public static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q addInPlace(Q q0,
                                                                                           QuaternionReadable4FType q1)

Calculate the element-wise sum of the quaternions q0 and q1, saving the result to q0.

Type Parameters:

Q - The precise type of quaternion

Parameters:

q0 - The left input quaternion

q1 - The right input quaternion

Returns:

(q0.x + q1.x, q0.y + q1.y, q0.z + q1.z, q0.w + q1.w)

almostEqual

public static boolean almostEqual(com.io7m.jequality.AlmostEqualFloat.ContextRelative context,
                                  QuaternionReadable4FType qa,
                                  QuaternionReadable4FType qb)

Determine whether or not the quaternions qa and qb are equal to within the degree of error given in context.

Parameters:

context - The equality context

qa - The left input quaternion

qb - The right input quaternion

Returns:

true if the quaternions are almost equal

Since:

5.0.0

See Also:

AlmostEqualFloat.almostEqual(ContextRelative, float, float)

conjugate

public static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q conjugate(QuaternionReadable4FType q,
                                                                                          Q out)

Calculate the conjugate of the input quaternion q, saving the result to out.

Type Parameters:

Q - The precise type of quaternion

Parameters:

q - The input quaternion

out - The output quaternion

Returns:

out

conjugateInPlace

public static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q conjugateInPlace(Q q)

Calculate the conjugate of the input quaternion q, modifying q in place.

Type Parameters:

Q - The precise type of quaternion

Parameters:

q - The input quaternion

Returns:

q

copy

public static <Q extends QuaternionWritable4FType> Q copy(QuaternionReadable4FType q,
                                                          Q out)

Copy the contents of the quaternion q to out.

Type Parameters:

Q - The precise type of quaternion

Parameters:

q - The input quaternion

out - The output quaternion

Returns:

out

dotProduct

public static double dotProduct(QuaternionReadable4FType q0,
                                QuaternionReadable4FType q1)

Calculate the scalar product of the quaternions q0 and q1.

Parameters:

q0 - The left input quaternion

q1 - The right input quaternion

Returns:

The scalar product of the two quaternions

interpolateLinear

public static <Q extends QuaternionWritable4FType> Q interpolateLinear(QuaternionM4F.ContextQM4F c,
                                                                       QuaternionReadable4FType q0,
                                                                       QuaternionReadable4FType q1,
                                                                       double alpha,
                                                                       Q r)

Linearly interpolate between q0 and q1 by the amount alpha, such that:

• interpolateLinear(q0, q1, 0.0, r) -> r = q0
• interpolateLinear(q0, q1, 1.0, r) -> r = q1

Type Parameters:

Q - The precise type of quaternion

Parameters:

c - Preallocated storage

q0 - The left input quaternion

q1 - The right input quaternion

alpha - The interpolation value, between 0.0 and 1.0

r - The output quaternion

Returns:

(1 - alpha) * q0 + alpha * q1

Since:

7.0.0

interpolateSphericalLinear

public static <Q extends QuaternionWritable4FType> Q interpolateSphericalLinear(QuaternionM4F.ContextQM4F c,
                                                                                QuaternionReadable4FType q0,
                                                                                QuaternionReadable4FType q1,
                                                                                float alpha,
                                                                                Q r)

Linearly interpolate between q0 and q1 by the amount alpha, such that:

• interpolateSphericalLinear(q0, q1, 0.0, r) -> r = q0
• interpolateSphericalLinear(q0, q1, 1.0, r) -> r = q1

Note that unlike simple linear interpolation, this function is guaranteed to return a normalized quaternion.

Type Parameters:

Q - The precise type of quaternion

Parameters:

c - Preallocated storage

q0 - The left input quaternion

q1 - The right input quaternion

alpha - The interpolation value, between 0.0 and 1.0

r - The output quaternion

Returns:

A spherical-linearly interpolated quaternion between q0 and q1

isNegationOf

public static boolean isNegationOf(com.io7m.jequality.AlmostEqualFloat.ContextRelative context,
                                   QuaternionReadable4FType qa,
                                   QuaternionReadable4FType qb)

Return true iff qa is the negation of qb.

Each element is compared with (ContextRelative, float, float).

Parameters:

context - The equality context

qa - The left quaternion

qb - The right quaternion

Returns:

true iff qa is the negation of qb

Since:

5.0.0

lookAt

public static <Q extends QuaternionWritable4FType> Q lookAt(QuaternionM4F.ContextQM4F context,
                                                            VectorReadable3FType origin,
                                                            VectorReadable3FType target,
                                                            VectorReadable3FType up,
                                                            Q q)

Produce a quaternion that represents a rotation that "looks at" the point at target assuming the viewer is at origin, using up as the "up" vector, saving the result to q.

The function uses storage preallocated in context to avoid any new allocations.

Type Parameters:

Q - The precise type of quaternion

Parameters:

context - Preallocated storage

q - The output quaternion

origin - The origin point

target - The target point

up - The up vector

Returns:

q

Since:

5.0.0

magnitude

public static double magnitude(QuaternionReadable4FType q)

Calculate the magnitude of the quaternion q. Correspondingly, magnitude(normalize(q)) == 1.0.

Parameters:

q - The input quaternion

Returns:

The magnitude of the input quaternion

magnitudeSquared

public static double magnitudeSquared(QuaternionReadable4FType q)

Calculate the squared magnitude of the quaternion q.

Parameters:

q - The input quaternion

Returns:

The squared magnitude of the input quaternion

makeFromAxisAngle

public static <Q extends QuaternionWritable4FType> Q makeFromAxisAngle(VectorReadable3FType axis,
                                                                       double angle,
                                                                       Q out)

Produce a quaternion that represents a rotation of angle degrees around the axis specified by axis, saving the result to out. axis is assumed to be of unit length.

Type Parameters:

Q - The precise type of quaternion

Parameters:

axis - The normalized vector representing the axis

angle - The angle to rotate, in radians

out - The output quaternion

Returns:

A quaternion representing the rotation

See Also:

VectorI3F.normalize(VectorReadable3FType), VectorI4F.normalize(VectorReadable4FType), VectorM3F.normalize(VectorReadable3FType, VectorWritable3FType), VectorM4F.normalize(VectorReadable4FType, VectorWritable4FType)

makeFromRotationMatrix3x3

public static <Q extends QuaternionWritable4FType> Q makeFromRotationMatrix3x3(MatrixReadable3x3FType m,
                                                                               Q out)

Produce a quaternion equivalent to the rotation matrix m, writing the result to out.

Type Parameters:

Q - The precise type of quaternion

Parameters:

m - The rotation matrix

out - The output quaternion

Returns:

out

Since:

5.0.0

makeFromRotationMatrix4x4

public static <Q extends QuaternionWritable4FType> Q makeFromRotationMatrix4x4(MatrixReadable4x4FType m,
                                                                               Q out)

Produce a quaternion equivalent to the rotation matrix m, writing the result to out.

Type Parameters:

Q - The precise type of quaternion

Parameters:

m - The rotation matrix

out - The output quaternion

Returns:

out

Since:

5.0.0

makeRotationMatrix3x3

public static <M extends MatrixWritable3x3FType> M makeRotationMatrix3x3(QuaternionReadable4FType q,
                                                                         M m)

Produce a rotation matrix from the quaternion q, saving the result to m.

Type Parameters:

M - The precise type of matrix

Parameters:

q - The input quaternion

m - The output matrix

Returns:

m

Since:

7.0.0

makeRotationMatrix4x4

public static <M extends MatrixWritable4x4FType> M makeRotationMatrix4x4(QuaternionReadable4FType q,
                                                                         M m)

Produce a rotation matrix from the quaternion q, saving the result to m.

Type Parameters:

M - The precise type of matrix.

Parameters:

q - The input quaternion

m - The output matrix

Returns:

m

Since:

5.0.0

multiply

public static <Q extends QuaternionWritable4FType> Q multiply(QuaternionReadable4FType q0,
                                                              QuaternionReadable4FType q1,
                                                              Q qr)

Multiply the quaternion q0 by the quaternion q1 , saving the result to qr.

Note that this operation is not commutative.

The function is most often used to concatenate quaternions to combine rotations. As an example, assuming that:

• qx represents some rotation around the X axis
• qy represents some rotation around the Y axis
• qz represents some rotation around the Z axis

The following code produces a quaternion qr that represents a rotation around the X axis, followed by a rotation around the Y axis, followed by a rotation around the Z axis:

QuaternionM4F qr = new QuaternionM4F(); QuaternionM4F.multiply(qy, qx, qr); QuaternionM4F.multiply(qz, qr, qr);

Type Parameters:

Q - The precise type of quaternion

Parameters:

q0 - The left input quaternion

q1 - The right input quaternion

qr - The output quaternion

Returns:

qr

multiplyInPlace

public static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q multiplyInPlace(Q q0,
                                                                                                QuaternionReadable4FType q1)

Multiply the quaternion q0 by the quaternion q1 , saving the result to q0.

Type Parameters:

Q - The precise type of quaternion

Parameters:

q0 - The left quaternion

q1 - The right quaternion

Returns:

q0

See Also:

multiply(QuaternionReadable4FType, QuaternionReadable4FType, QuaternionWritable4FType)

negate

public static <Q extends QuaternionWritable4FType> Q negate(QuaternionReadable4FType qa,
                                                            Q out)

Negate the elements of qa, writing the resulting quaternion to out.

Type Parameters:

Q - The precise type of quaternion

Parameters:

qa - The input quaternion

out - The output quaternion

Returns:

out

Since:

5.0.0

negateInPlace

public static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q negateInPlace(Q q)

Negate the elements of q, modifying the quaternion in-place.

Type Parameters:

Q - The precise type of quaternion

Parameters:

q - The input quaternion

Returns:

q

Since:

5.0.0

normalize

public static <Q extends QuaternionWritable4FType> Q normalize(QuaternionReadable4FType q,
                                                               Q out)

Returns a quaternion with the same orientation as q but with magnitude equal to 1.0 in out. The function returns the zero quaternion iff the input is the zero quaternion.

Type Parameters:

Q - The precise type of quaternion

Parameters:

out - The output quaternion

q - The input quaternion

Returns:

out

normalizeInPlace

public static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q normalizeInPlace(Q q)

Returns a quaternion with the same orientation as q but with magnitude equal to 1.0 in q. The function returns the zero quaternion iff the input is the zero quaternion.

Type Parameters:

Q - The precise type of quaternion

Parameters:

q - The input quaternion

Returns:

q

scale

public static <Q extends QuaternionWritable4FType> Q scale(QuaternionReadable4FType q,
                                                           double r,
                                                           Q out)

Scale the quaternion q by the scalar r, saving the result to out.

Type Parameters:

Q - The precise type of quaternion

Parameters:

q - The input quaternion

r - The scaling value

out - The output quaternion

Returns:

(q.x * r, q.y * r, q.z * r, q.w * r)

scaleInPlace

public static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q scaleInPlace(Q q,
                                                                                             double r)

Scale the quaternion q by the scalar r, saving the result to q.

Type Parameters:

Q - The precise type of quaternion

Parameters:

q - The input quaternion

r - The scaling value

Returns:

(q.x * r, q.y * r, q.z * r, q.w * r)

subtract

public static <Q extends QuaternionWritable4FType> Q subtract(QuaternionReadable4FType q0,
                                                              QuaternionReadable4FType q1,
                                                              Q out)

Subtract the quaternion q0 from the quaternion q1, saving the result to out.

Type Parameters:

Q - The precise type of quaternion

Parameters:

q0 - The left input quaternion

q1 - The right input quaternion

out - The output quaternion

Returns:

(q0.x - q1.x, q0.y - q1.y, q0.z - q1.z, q0.w - q1.w)

subtractInPlace

public static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q subtractInPlace(Q q0,
                                                                                                QuaternionReadable4FType q1)

Subtract the quaternion q0 from the quaternion q1, saving the result to q0.

Type Parameters:

Q - The precise type of quaternion

Parameters:

q0 - The left input quaternion

q1 - The right input quaternion

Returns:

(q0.x - q1.x, q0.y - q1.y, q0.z - q1.z, q0.w - q1.w)

toAxisAngle

public static <V extends VectorWritable3FType> double toAxisAngle(QuaternionReadable4FType q,
                                                                  V out)

Determine the axis-angle representation of the given quaternion.

Type Parameters:

V - The precise type of output vector

Parameters:

q - The input quaternion

out - The output vector that will contain the axis

Returns:

The angle

copyFrom2F

public void copyFrom2F(VectorReadable2FType in_v)

Description copied from interface: VectorWritable2FType

Set the current vector to the contents of the input vector.

Specified by:

copyFrom2F in interface VectorWritable2FType

Parameters:

in_v - The input vector

copyFrom3F

public void copyFrom3F(VectorReadable3FType in_v)

Description copied from interface: VectorWritable3FType

Set the current vector to the contents of the input vector.

Specified by:

copyFrom3F in interface VectorWritable3FType

Parameters:

in_v - The input vector

copyFrom4F

public void copyFrom4F(VectorReadable4FType in_v)

Description copied from interface: VectorWritable4FType

Set the current vector to the contents of the input vector.

Specified by:

copyFrom4F in interface VectorWritable4FType

Parameters:

in_v - The input vector

equals

public boolean equals(@Nullable
                      Object obj)

Overrides:

equals in class Object

getWF

public float getWF()

Specified by:

getWF in interface VectorReadable4FType

Returns:

The W value of the given vector.

setWF

public void setWF(float in_w)

Description copied from interface: VectorWritable4FType

Set the current w value of the current vector.

Specified by:

setWF in interface VectorWritable4FType

Parameters:

in_w - The new w value.

getXF

public float getXF()

Specified by:

getXF in interface VectorReadable2FType

Returns:

The X value of the given vector.

setXF

public void setXF(float in_x)

Description copied from interface: VectorWritable2FType

Set the current x value of the current vector.

Specified by:

setXF in interface VectorWritable2FType

Parameters:

in_x - The new x value.

getYF

public float getYF()

Specified by:

getYF in interface VectorReadable2FType

Returns:

The Y value of the given vector.

setYF

public void setYF(float in_y)

Description copied from interface: VectorWritable2FType

Set the current y value of the current vector.

Specified by:

setYF in interface VectorWritable2FType

Parameters:

in_y - The new y value.

getZF

public float getZF()

Specified by:

getZF in interface VectorReadable3FType

Returns:

The Z value of the given vector.

setZF

public void setZF(float in_z)

Description copied from interface: VectorWritable3FType

Set the current z value of the current vector.

Specified by:

setZF in interface VectorWritable3FType

Parameters:

in_z - The new z value.

hashCode

public int hashCode()

Overrides:

hashCode in class Object

set2F

public void set2F(float in_x,
                  float in_y)

Description copied from interface: VectorWritable2FType

Set the current x and y values of the current vector.

Specified by:

set2F in interface VectorWritable2FType

Parameters:

in_x - The new x value.

in_y - The new y value.

set3F

public void set3F(float in_x,
                  float in_y,
                  float in_z)

Description copied from interface: VectorWritable3FType

Set the current x, y and z values of the current vector.

Specified by:

set3F in interface VectorWritable3FType

Parameters:

in_x - The new x value.

in_y - The new y value.

in_z - The new z value.

set4F

public void set4F(float in_x,
                  float in_y,
                  float in_z,
                  float in_w)

Description copied from interface: VectorWritable4FType

Set the current x, y, z and w values of the current vector.

Specified by:

set4F in interface VectorWritable4FType

Parameters:

in_x - The new x value.

in_y - The new y value.

in_z - The new z value.

in_w - The new w value.

toString

public String toString()

Overrides:

toString in class Object