All Known Implementing Classes:
AABB, Cone, Plane, PointOctree, Ray3D, Sphere, Vec3D, Vertex, WEVertex

`public interface ReadonlyVec3D`

Readonly, immutable interface wrapper for Vec3D instances. Used throughout the library for safety purposes.

Method Summary
` Vec3D` ```add(float a, float b, float c)```
Adds vector {a,b,c} and returns result as new vector.
` Vec3D` `add(ReadonlyVec3D v)`

` Vec3D` `add(Vec3D v)`
Add vector v and returns result as new vector.
` float` `angleBetween(ReadonlyVec3D v)`
Computes the angle between this vector and vector V.
` float` ```angleBetween(ReadonlyVec3D v, boolean forceNormalize)```
Computes the angle between this vector and vector V.
` int` `compareTo(ReadonlyVec3D v)`
Compares the length of the vector with another one.
` Vec3D` `copy()`
Copy.
` Vec3D` `cross(ReadonlyVec3D v)`
Calculates cross-product with vector v.
` Vec3D` ```crossInto(ReadonlyVec3D v, Vec3D result)```
Calculates cross-product with vector v.
` float` `distanceTo(ReadonlyVec3D v)`
Calculates distance to another vector.
` float` `distanceToSquared(ReadonlyVec3D v)`
Calculates the squared distance to another vector.
` float` `dot(ReadonlyVec3D v)`
Computes the scalar product (dot product) with the given vector.
` boolean` `equals(java.lang.Object obj)`

` boolean` ```equalsWithTolerance(ReadonlyVec3D v, float tolerance)```
Compares this vector with the one given.
` Vec3D` `getAbs()`
Gets the abs.
` float` `getComponent(int id)`

` float` `getComponent(Vec3D.Axis id)`

` Vec3D` `getConstrained(AABB box)`
Creates a copy of the vector which forcefully fits in the given AABB.
` Vec3D` `getFloored()`
Creates a new vector whose components are the integer value of their current values.
` Vec3D` `getFrac()`
Creates a new vector whose components are the fractional part of their current values.
` Vec3D` `getInverted()`
Scales vector uniformly by factor -1 ( v = -v ).
` Vec3D` `getLimited(float lim)`
Creates a copy of the vector with its magnitude limited to the length given.
` Vec3D` `getNormalized()`
Produces the normalized version as a new vector.
` Vec3D` `getNormalizedTo(float len)`
Produces a new vector normalized to the given length.
` Vec3D` `getReciprocal()`
Returns a multiplicative inverse copy of the vector.
` Vec3D` `getReflected(ReadonlyVec3D normal)`

` Vec3D` ```getRotatedAroundAxis(ReadonlyVec3D axis, float theta)```
Gets the rotated around axis.
` Vec3D` `getRotatedX(float theta)`
Creates a new vector rotated by the given angle around the X axis.
` Vec3D` `getRotatedY(float theta)`
Creates a new vector rotated by the given angle around the Y axis.
` Vec3D` `getRotatedZ(float theta)`
Creates a new vector rotated by the given angle around the Z axis.
` Vec3D` `getSignum()`
Creates a new vector in which all components are replaced with the signum of their original values.
` float` `headingXY()`
Computes the vector's direction in the XY plane (for example for 2D points).
` float` `headingXZ()`
Computes the vector's direction in the XZ plane.
` float` `headingYZ()`
Computes the vector's direction in the YZ plane.
` Vec3D` ```interpolateTo(ReadonlyVec3D v, float f)```
Interpolates the vector towards the given target vector, using linear interpolation.
` Vec3D` ```interpolateTo(ReadonlyVec3D v, float f, InterpolateStrategy s)```
Interpolates the vector towards the given target vector, using the given `InterpolateStrategy`.
` boolean` `isInAABB(AABB box)`
Checks if the point is inside the given AABB.
` boolean` ```isInAABB(Vec3D boxOrigin, Vec3D boxExtent)```
Checks if the point is inside the given axis-aligned bounding box.
` boolean` `isMajorAxis(float tolerance)`
Checks if the vector is parallel with either the X or Y axis (any direction).
` boolean` `isZeroVector()`
Checks if vector has a magnitude equals or close to zero (tolerance used is `MathUtils.EPS`).
` float` `magnitude()`
Calculates the magnitude/eucledian length of the vector.
` float` `magSquared()`
Calculates only the squared magnitude/length of the vector.
` Vec3D` `scale(float s)`
Scales vector uniformly and returns result as new vector.
` Vec3D` ```scale(float a, float b, float c)```
Scales vector non-uniformly and returns result as new vector.
` Vec3D` `scale(ReadonlyVec3D s)`
Scales vector non-uniformly by vector v and returns result as new vector.
` Vec3D` ```sub(float a, float b, float c)```
Subtracts vector {a,b,c} and returns result as new vector.
` Vec3D` `sub(ReadonlyVec3D v)`
Subtracts vector v and returns result as new vector.
` Vec2D` `to2DXY()`
Creates a new 2D vector of the XY components.
` Vec2D` `to2DXZ()`
Creates a new 2D vector of the XZ components.
` Vec2D` `to2DYZ()`
Creates a new 2D vector of the YZ components.
` float[]` `toArray()`

` Vec3D` `toCartesian()`
Converts the spherical vector back into cartesian coordinates.
` Vec3D` `toSpherical()`
Converts the vector into spherical coordinates.
` float` `x()`

` float` `y()`

` float` `z()`

Method Detail

```Vec3D add(float a,
float b,
float c)```
Adds vector {a,b,c} and returns result as new vector.

Parameters:
`a` - X coordinate
`b` - Y coordinate
`c` - Z coordinate
Returns:
result as new vector

`Vec3D add(ReadonlyVec3D v)`

`Vec3D add(Vec3D v)`
Add vector v and returns result as new vector.

Parameters:
`v` - vector to add
Returns:
result as new vector

angleBetween

`float angleBetween(ReadonlyVec3D v)`
Computes the angle between this vector and vector V. This function assumes both vectors are normalized, if this can't be guaranteed, use the alternative implementation `angleBetween(ReadonlyVec3D, boolean)`

Parameters:
`v` - vector
Returns:
angle in radians, or NaN if vectors are parallel

angleBetween

```float angleBetween(ReadonlyVec3D v,
boolean forceNormalize)```
Computes the angle between this vector and vector V.

Parameters:
`v` - vector
`forceNormalize` - true, if normalized versions of the vectors are to be used (Note: only copies will be used, original vectors will not be altered by this method)
Returns:
angle in radians, or NaN if vectors are parallel

compareTo

`int compareTo(ReadonlyVec3D v)`
Compares the length of the vector with another one.

Parameters:
`v` - vector to compare with
Returns:
-1 if other vector is longer, 0 if both are equal or else +1

copy

`Vec3D copy()`
Copy.

Returns:
a new independent instance/copy of a given vector

cross

`Vec3D cross(ReadonlyVec3D v)`
Calculates cross-product with vector v. The resulting vector is perpendicular to both the current and supplied vector.

Parameters:
`v` - vector to cross
Returns:
cross-product as new vector

crossInto

```Vec3D crossInto(ReadonlyVec3D v,
Vec3D result)```
Calculates cross-product with vector v. The resulting vector is perpendicular to both the current and supplied vector and stored in the supplied result vector.

Parameters:
`v` - vector to cross
`result` - result vector
Returns:
result vector

distanceTo

`float distanceTo(ReadonlyVec3D v)`
Calculates distance to another vector.

Parameters:
`v` - non-null vector
Returns:
distance or Float.NaN if v=null

distanceToSquared

`float distanceToSquared(ReadonlyVec3D v)`
Calculates the squared distance to another vector.

Parameters:
`v` - non-null vector
Returns:
distance or NaN if v=null
`magSquared()`

dot

`float dot(ReadonlyVec3D v)`
Computes the scalar product (dot product) with the given vector.

Parameters:
`v` - the v
Returns:
dot product
Wikipedia entry

equals

`boolean equals(java.lang.Object obj)`
Overrides:
`equals` in class `java.lang.Object`

equalsWithTolerance

```boolean equalsWithTolerance(ReadonlyVec3D v,
float tolerance)```
Compares this vector with the one given. The vectors are deemed equal if the individual differences of all component values are within the given tolerance.

Parameters:
`v` - the v
`tolerance` - the tolerance
Returns:
true, if equal

getAbs

`Vec3D getAbs()`
Gets the abs.

Returns:
the abs

getComponent

`float getComponent(Vec3D.Axis id)`

getComponent

`float getComponent(int id)`

getConstrained

`Vec3D getConstrained(AABB box)`
Creates a copy of the vector which forcefully fits in the given AABB.

Parameters:
`box` - the box
Returns:
fitted vector

getFloored

`Vec3D getFloored()`
Creates a new vector whose components are the integer value of their current values.

Returns:
result as new vector

getFrac

`Vec3D getFrac()`
Creates a new vector whose components are the fractional part of their current values.

Returns:
result as new vector

getInverted

`Vec3D getInverted()`
Scales vector uniformly by factor -1 ( v = -v ).

Returns:
result as new vector

getLimited

`Vec3D getLimited(float lim)`
Creates a copy of the vector with its magnitude limited to the length given.

Parameters:
`lim` - new maximum magnitude
Returns:
result as new vector

getNormalized

`Vec3D getNormalized()`
Produces the normalized version as a new vector.

Returns:
new vector

getNormalizedTo

`Vec3D getNormalizedTo(float len)`
Produces a new vector normalized to the given length.

Parameters:
`len` - new desired length
Returns:
new vector

getReciprocal

`Vec3D getReciprocal()`
Returns a multiplicative inverse copy of the vector.

Returns:
new vector

getReflected

`Vec3D getReflected(ReadonlyVec3D normal)`

getRotatedAroundAxis

```Vec3D getRotatedAroundAxis(ReadonlyVec3D axis,
float theta)```
Gets the rotated around axis.

Parameters:
`axis` - the axis
`theta` - the theta
Returns:
new result vector

getRotatedX

`Vec3D getRotatedX(float theta)`
Creates a new vector rotated by the given angle around the X axis.

Parameters:
`theta` - the theta
Returns:
rotated vector

getRotatedY

`Vec3D getRotatedY(float theta)`
Creates a new vector rotated by the given angle around the Y axis.

Parameters:
`theta` - the theta
Returns:
rotated vector

getRotatedZ

`Vec3D getRotatedZ(float theta)`
Creates a new vector rotated by the given angle around the Z axis.

Parameters:
`theta` - the theta
Returns:
rotated vector

getSignum

`Vec3D getSignum()`
Creates a new vector in which all components are replaced with the signum of their original values. In other words if a components value was negative its new value will be -1, if zero => 0, if positive => +1

Returns:
result vector

`float headingXY()`
Computes the vector's direction in the XY plane (for example for 2D points). The positive X axis equals 0 degrees.

Returns:
rotation angle

`float headingXZ()`
Computes the vector's direction in the XZ plane. The positive X axis equals 0 degrees.

Returns:
rotation angle

`float headingYZ()`
Computes the vector's direction in the YZ plane. The positive Z axis equals 0 degrees.

Returns:
rotation angle

interpolateTo

```Vec3D interpolateTo(ReadonlyVec3D v,
float f)```
Interpolates the vector towards the given target vector, using linear interpolation.

Parameters:
`v` - target vector
`f` - interpolation factor (should be in the range 0..1)
Returns:
result as new vector

interpolateTo

```Vec3D interpolateTo(ReadonlyVec3D v,
float f,
InterpolateStrategy s)```
Interpolates the vector towards the given target vector, using the given `InterpolateStrategy`.

Parameters:
`v` - target vector
`f` - interpolation factor (should be in the range 0..1)
`s` - InterpolateStrategy instance
Returns:
result as new vector

isInAABB

`boolean isInAABB(AABB box)`
Checks if the point is inside the given AABB.

Parameters:
`box` - bounding box to check
Returns:
true, if point is inside

isInAABB

```boolean isInAABB(Vec3D boxOrigin,
Vec3D boxExtent)```
Checks if the point is inside the given axis-aligned bounding box.

Parameters:
`boxOrigin` - bounding box origin/center
`boxExtent` - bounding box extends (half measure)
Returns:
true, if point is inside the box

isMajorAxis

`boolean isMajorAxis(float tolerance)`
Checks if the vector is parallel with either the X or Y axis (any direction).

Parameters:
`tolerance` -
Returns:
true, if parallel within the given tolerance

isZeroVector

`boolean isZeroVector()`
Checks if vector has a magnitude equals or close to zero (tolerance used is `MathUtils.EPS`).

Returns:
true, if zero vector

magnitude

`float magnitude()`
Calculates the magnitude/eucledian length of the vector.

Returns:
vector length

magSquared

`float magSquared()`
Calculates only the squared magnitude/length of the vector. Useful for inverse square law applications and/or for speed reasons or if the real eucledian distance is not required (e.g. sorting).

Returns:
squared magnitude (x^2 + y^2 + z^2)

scale

`Vec3D scale(float s)`
Scales vector uniformly and returns result as new vector.

Parameters:
`s` - scale factor
Returns:
new vector

scale

```Vec3D scale(float a,
float b,
float c)```
Scales vector non-uniformly and returns result as new vector.

Parameters:
`a` - scale factor for X coordinate
`b` - scale factor for Y coordinate
`c` - scale factor for Z coordinate
Returns:
new vector

scale

`Vec3D scale(ReadonlyVec3D s)`
Scales vector non-uniformly by vector v and returns result as new vector.

Parameters:
`s` - scale vector
Returns:
new vector

sub

```Vec3D sub(float a,
float b,
float c)```
Subtracts vector {a,b,c} and returns result as new vector.

Parameters:
`a` - X coordinate
`b` - Y coordinate
`c` - Z coordinate
Returns:
result as new vector

sub

`Vec3D sub(ReadonlyVec3D v)`
Subtracts vector v and returns result as new vector.

Parameters:
`v` - vector to be subtracted
Returns:
result as new vector

to2DXY

`Vec2D to2DXY()`
Creates a new 2D vector of the XY components.

Returns:
new vector

to2DXZ

`Vec2D to2DXZ()`
Creates a new 2D vector of the XZ components.

Returns:
new vector

to2DYZ

`Vec2D to2DYZ()`
Creates a new 2D vector of the YZ components.

Returns:
new vector

toArray

`float[] toArray()`

toCartesian

`Vec3D toCartesian()`
Converts the spherical vector back into cartesian coordinates.

Returns:
itself

toSpherical

`Vec3D toSpherical()`
Converts the vector into spherical coordinates. After the conversion the vector components are to be interpreted as:
• y = azimuth
• z = theta

Returns:
itself

x

`float x()`

y

`float y()`

z

`float z()`