functions

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
final val E: Double(2.718281828459045)

Constant e.
final val Epsilon: Double(2.220446049250313E-16)

Machine float epsilon, pow(2, -52).
final val Pi: Double(3.141592653589793)

Constant pi.
def abs(u: inVec4d): Vec4d
def abs(u: inVec3d): Vec3d
def abs(u: inVec2d): Vec2d
def abs(x: Double): Double
final def abs(u: inVec4i): Vec4i

Applies abs function to each component.
Applies abs function to each component.
u
an integer vector argument.
returns
a vector with components set to absolute values of components of u.
final def abs(u: inVec3i): Vec3i

Applies abs function to each component.
Applies abs function to each component.
u
an integer vector argument.
returns
a vector with components set to absolute values of components of u.
final def abs(u: inVec2i): Vec2i

Applies abs function to each component.
Applies abs function to each component.
u
an integer vector argument.
returns
a vector with components set to absolute values of components of u.
final def abs(x: Int): Int

Returns an absolute value of the argument.
Returns an absolute value of the argument.
x
an integer argument.
returns
an absolute value of the agument.
def acos(u: inVec4d): Vec4d
def acos(u: inVec3d): Vec3d
def acos(u: inVec2d): Vec2d
def acos(w: Double): Double
def acosh(u: inVec4d): Vec4d
def acosh(u: inVec3d): Vec3d
def acosh(u: inVec2d): Vec2d
def acosh(x: Double): Double
def angleAxis(m: inMat3d, axis: Vec3d): Double

The matrix must represent non-scaling rotation to achieve the desired result.
The matrix must represent non-scaling rotation to achieve the desired result. If the matrix represents 0 degree rotation, then rotation axis is undefined, in this case the UnitX axis is chosen.
def angleAxis(q: inQuat4d, axis: Vec3d): Double

The quaternion must have unit norm to achieve the desired result.
The quaternion must have unit norm to achieve the desired result. If quaternion represents 0 degree rotation, then rotation axis is not defined, in this case the UnitX axis is chosen.
def approxEqual(m: inMat4d, n: inMat4d, absDelta: Double): Boolean
def approxEqual(m: inMat3x4d, n: inMat3x4d, absDelta: Double): Boolean
def approxEqual(m: inMat2x4d, n: inMat2x4d, absDelta: Double): Boolean
def approxEqual(m: inMat4x3d, n: inMat4x3d, absDelta: Double): Boolean
def approxEqual(m: inMat3d, n: inMat3d, absDelta: Double): Boolean
def approxEqual(m: inMat2x3d, n: inMat2x3d, absDelta: Double): Boolean
def approxEqual(m: inMat4x2d, n: inMat4x2d, absDelta: Double): Boolean
def approxEqual(m: inMat3x2d, n: inMat3x2d, absDelta: Double): Boolean
def approxEqual(m: inMat2d, n: inMat2d, absDelta: Double): Boolean
def approxEqual(p: inQuat4d, q: inQuat4d, absDelta: Double): Boolean
def approxEqual(u: inVec4d, v: inVec4d, absDelta: Double): Boolean
def approxEqual(u: inVec3d, v: inVec3d, absDelta: Double): Boolean
def approxEqual(u: inVec2d, v: inVec2d, absDelta: Double): Boolean
def approxEqual(x: Double, y: Double, absDelta: Double): Boolean
final def asInstanceOf[T0]: T0

Definition Classes
Any
def asin(u: inVec4d): Vec4d
def asin(u: inVec3d): Vec3d
def asin(u: inVec2d): Vec2d
def asin(w: Double): Double
def asinh(u: inVec4d): Vec4d
def asinh(u: inVec3d): Vec3d
def asinh(u: inVec2d): Vec2d
def asinh(x: Double): Double
def atan(u: inVec4d): Vec4d
def atan(uy: inVec4d, ux: inVec4d): Vec4d
def atan(u: inVec3d): Vec3d
def atan(uy: inVec3d, ux: inVec3d): Vec3d
def atan(u: inVec2d): Vec2d
def atan(uy: inVec2d, ux: inVec2d): Vec2d
def atan(w: Double): Double
def atan(y: Double, x: Double): Double
def atanh(u: inVec4d): Vec4d
def atanh(u: inVec3d): Vec3d
def atanh(u: inVec2d): Vec2d
def atanh(x: Double): Double
def ceil(u: inVec4d): Vec4d
def ceil(u: inVec3d): Vec3d
def ceil(u: inVec2d): Vec2d
def ceil(x: Double): Double
def clamp(u: inVec4d, minVal: inVec4d, maxVal: inVec4d): Vec4d
def clamp(u: inVec4d, minVal: Double, maxVal: Double): Vec4d
def clamp(u: inVec3d, minVal: inVec3d, maxVal: inVec3d): Vec3d
def clamp(u: inVec3d, minVal: Double, maxVal: Double): Vec3d
def clamp(u: inVec2d, minVal: inVec2d, maxVal: inVec2d): Vec2d
def clamp(u: inVec2d, minVal: Double, maxVal: Double): Vec2d
def clamp(x: Double, minVal: Double, maxVal: Double): Double
final def clamp(u: inVec4i, minVal: inVec4i, maxVal: inVec4i): Vec4i

Applies clamp function to each component.
Applies clamp function to each component.
u
an integer vector argument.
minVal
a vector with components used as lower bound (inclusive).
maxVal
a vector with components used as upper bound (inclusive).
returns
a vector with components set to clamp(u.c, minVal.c, maxVal.c) for each component c.
final def clamp(u: inVec4i, minVal: Int, maxVal: Int): Vec4i

Clamps components to the range from minValue (inclusive) to maxValue (inclusive).
Clamps components to the range from minValue (inclusive) to maxValue (inclusive).
u
an integer vector argument.
minVal
the lower bound (inclusive).
maxVal
the upper bound (inclusive).
returns
a vector with components clamped to [minValue, maxValue].
final def clamp(u: inVec3i, minVal: inVec3i, maxVal: inVec3i): Vec3i

Applies clamp function to each component.
Applies clamp function to each component.
u
an integer vector argument.
minVal
a vector with components used as lower bound (inclusive).
maxVal
a vector with components used as upper bound (inclusive).
returns
a vector with components set to clamp(u.c, minVal.c, maxVal.c) for each component c.
final def clamp(u: inVec3i, minVal: Int, maxVal: Int): Vec3i

Clamps components to the range from minValue (inclusive) to maxValue (inclusive).
Clamps components to the range from minValue (inclusive) to maxValue (inclusive).
u
an integer vector argument.
minVal
the lower bound (inclusive).
maxVal
the upper bound (inclusive).
returns
a vector with components clamped to [minValue, maxValue].
final def clamp(u: inVec2i, minVal: inVec2i, maxVal: inVec2i): Vec2i

Applies clamp function to each component.
Applies clamp function to each component.
u
an integer vector argument.
minVal
a vector with components used as lower bound (inclusive).
maxVal
a vector with components used as upper bound (inclusive).
returns
a vector with components set to clamp(u.c, minVal.c, maxVal.c) for each component c.
final def clamp(u: inVec2i, minVal: Int, maxVal: Int): Vec2i

Clamps components to the range from minValue (inclusive) to maxValue (inclusive).
Clamps components to the range from minValue (inclusive) to maxValue (inclusive).
u
an integer vector argument.
minVal
the lower bound (inclusive).
maxVal
the upper bound (inclusive).
returns
a vector with components clamped to [minValue, maxValue].
final def clamp(x: Int, minVal: Int, maxVal: Int): Int

Clamps a value to a given range.
Clamps a value to a given range. Note: the result is undefined if minVal > maxVal.
x
an integer value to clamp.
minVal
the lower bound (inclusive).
maxVal
the upper bound (inclusive).
returns
one of the following:
- minVal if x < minVal.
- maxVal if x > maxVal.
- x otherwise.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws()
def conjugate(q: inQuat4d): Quat4d
def cos(u: inVec4d): Vec4d
def cos(u: inVec3d): Vec3d
def cos(u: inVec2d): Vec2d
def cos(w: Double): Double
def cosh(u: inVec4d): Vec4d
def cosh(u: inVec3d): Vec3d
def cosh(u: inVec2d): Vec2d
def cosh(x: Double): Double
def cross(u: inVec3d, v: inVec3d): Vec3d
def degrees(u: inVec4d): Vec4d
def degrees(u: inVec3d): Vec3d
def degrees(u: inVec2d): Vec2d
def degrees(x: Double): Double
def determinant(m: inMat4d): Double
def determinant(m: inMat3d): Double
def determinant(m: inMat2d): Double
def distance(u: inVec4d, v: inVec4d): Double
def distance(u: inVec3d, v: inVec3d): Double
def distance(u: inVec2d, v: inVec2d): Double
def distance(x: Double, y: Double): Double
def dot(u: inVec4d, v: inVec4d): Double
def dot(u: inVec3d, v: inVec3d): Double
def dot(u: inVec2d, v: inVec2d): Double
def dot(x: Double, y: Double): Double
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equal(u: inVec4d, v: inVec4d): Vec4b
def equal(u: inVec3d, v: inVec3d): Vec3b
def equal(u: inVec2d, v: inVec2d): Vec2b
final def equal(u: inVec4i, v: inVec4i): Vec4b

Performs component-wise equal comparison.
Performs component-wise equal comparison.
u
an integer vector on the left-hand side of comparison.
v
an integer vector on the right-hand side of comparison.
returns
a boolean vector with components set to (u.c == v.c) for each component c.
final def equal(u: inVec3i, v: inVec3i): Vec3b

Performs component-wise equal comparison.
Performs component-wise equal comparison.
u
an integer vector on the left-hand side of comparison.
v
an integer vector on the right-hand side of comparison.
returns
a boolean vector with components set to (u.c == v.c) for each component c.
final def equal(u: inVec2i, v: inVec2i): Vec2b

Performs component-wise equal comparison.
Performs component-wise equal comparison.
u
an integer vector on the left-hand side of comparison.
v
an integer vector on the right-hand side of comparison.
returns
a boolean vector with components set to (u.c == v.c) for each component c.
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def exp(u: inVec4d): Vec4d
def exp(u: inVec3d): Vec3d
def exp(u: inVec2d): Vec2d
def exp(x: Double): Double
def exp2(u: inVec4d): Vec4d
def exp2(u: inVec3d): Vec3d
def exp2(u: inVec2d): Vec2d
def exp2(x: Double): Double
def faceforward(n: inVec4d, i: inVec4d, nref: inVec4d): Vec4d
def faceforward(n: inVec3d, i: inVec3d, nref: inVec3d): Vec3d
def faceforward(n: inVec2d, i: inVec2d, nref: inVec2d): Vec2d
def faceforward(n: Double, i: Double, nref: Double): Double
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws()
def floor(u: inVec4d): Vec4d
def floor(u: inVec3d): Vec3d
def floor(u: inVec2d): Vec2d
def floor(x: Double): Double
def fract(u: inVec4d): Vec4d
def fract(u: inVec3d): Vec3d
def fract(u: inVec2d): Vec2d
def fract(x: Double): Double

Equivalent to x - floor(x)
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def greaterThan(u: inVec4d, v: inVec4d): Vec4b
def greaterThan(u: inVec3d, v: inVec3d): Vec3b
def greaterThan(u: inVec2d, v: inVec2d): Vec2b
final def greaterThan(u: inVec4i, v: inVec4i): Vec4b

Performs component-wise greater than comparison.
Performs component-wise greater than comparison.
u
an integer vector on the left-hand side of comparison.
v
an integer vector on the right-hand side of comparison.
returns
a boolean vector with components set to (u.c > v.c) for each component c.
final def greaterThan(u: inVec3i, v: inVec3i): Vec3b

Performs component-wise greater than comparison.
Performs component-wise greater than comparison.
u
an integer vector on the left-hand side of comparison.
v
an integer vector on the right-hand side of comparison.
returns
a boolean vector with components set to (u.c > v.c) for each component c.
final def greaterThan(u: inVec2i, v: inVec2i): Vec2b

Performs component-wise greater than comparison.
Performs component-wise greater than comparison.
u
an integer vector on the left-hand side of comparison.
v
an integer vector on the right-hand side of comparison.
returns
a boolean vector with components set to (u.c > v.c) for each component c.
def greaterThanEqual(u: inVec4d, v: inVec4d): Vec4b
def greaterThanEqual(u: inVec3d, v: inVec3d): Vec3b
def greaterThanEqual(u: inVec2d, v: inVec2d): Vec2b
final def greaterThanEqual(u: inVec4i, v: inVec4i): Vec4b

Performs component-wise greater than or equal comparison.
Performs component-wise greater than or equal comparison.
u
an integer vector on the left-hand side of comparison.
v
an integer vector on the right-hand side of comparison.
returns
a boolean vector with components set to (u.c >= v.c) for each component c.
final def greaterThanEqual(u: inVec3i, v: inVec3i): Vec3b

Performs component-wise greater than or equal comparison.
Performs component-wise greater than or equal comparison.
u
an integer vector on the left-hand side of comparison.
v
an integer vector on the right-hand side of comparison.
returns
a boolean vector with components set to (u.c >= v.c) for each component c.
final def greaterThanEqual(u: inVec2i, v: inVec2i): Vec2b

Performs component-wise greater than or equal comparison.
Performs component-wise greater than or equal comparison.
u
an integer vector on the left-hand side of comparison.
v
an integer vector on the right-hand side of comparison.
returns
a boolean vector with components set to (u.c >= v.c) for each component c.
def hasErrors(m: inMat4d): Boolean
def hasErrors(m: inMat3x4d): Boolean
def hasErrors(m: inMat2x4d): Boolean
def hasErrors(m: inMat4x3d): Boolean
def hasErrors(m: inMat3d): Boolean
def hasErrors(m: inMat2x3d): Boolean
def hasErrors(m: inMat4x2d): Boolean
def hasErrors(m: inMat3x2d): Boolean
def hasErrors(m: inMat2d): Boolean
def hasErrors(q: inQuat4d): Boolean
def hasErrors(u: inVec4d): Boolean
def hasErrors(u: inVec3d): Boolean
def hasErrors(u: inVec2d): Boolean
def hasErrors(x: Double): Boolean
def hashCode(): Int

Definition Classes
AnyRef → Any
def inverse(q: inQuat4d): Quat4d

This method is here for completness.
This method is here for completness. Normally you should work with unit quaternions (norm(q) == 1), and in this case inverse(q) == conjugate(q).
def inverse(m: inMat4x3d): Mat4x3d

This method is equivalent to casting the matrix to 4x4, inverting it and then casting the result back to 4x3.
This method is equivalent to casting the matrix to 4x4, inverting it and then casting the result back to 4x3.
This is a general matrix inverse. You can invert transofrmations quicker by using Transform3d.inverse(scale, rotation, translation). A rotation matrix that does not scale can be inverted even faster by using transpose. In the latter case you can avoid inverse alltogether by using transpose multiplication: instead of multiplying a matrix by a vectors (M*v), you can multiply the vector by the matrix (v*M).

If matrix determinant is zero the result is undefined.
def inverse(m: inMat3x2d): Mat3x2d

This method is equivalent to casting the matrix to 3x3, inverting it and then casting the result back to 3x2.
This method is equivalent to casting the matrix to 3x3, inverting it and then casting the result back to 3x2.
This is a general matrix inverse. You can invert transofrmations quicker by using Transform2d.inverse(scale, rotation, translation). A rotation matrix that does not scale can be inverted even faster by using transpose. In the latter case you can avoid inverse alltogether by using transpose multiplication: instead of multiplying a matrix by a vectors (M*v), you can multiply the vector by the matrix (v*M).

If matrix determinant is zero the result is undefined.
def inverse(m: inMat4d): Mat4d

This is a general matrix inverse.
This is a general matrix inverse. You can invert transofrmations quicker by using Transform3d.inverse(scale, rotation, translation). A rotation matrix that does not scale can be inverted even faster by using transpose. In the latter case you can avoid inverse alltogether by using transpose multiplication: instead of multiplying a matrix by a vectors (M*v), you can multiply the vector by the matrix (v*M).

If matrix determinant is zero the result is undefined.
def inverse(m: inMat3d): Mat3d

This is a general matrix inverse.
This is a general matrix inverse. You can invert transofrmations quicker by using Transform3d.inverse(scale, rotation, translation). A rotation matrix that does not scale can be inverted even faster by using transpose. In the latter case you can avoid inverse alltogether by using transpose multiplication: instead of multiplying a matrix by a vectors (M*v), you can multiply the vector by the matrix (v*M).

If matrix determinant is zero the result is undefined.
def inverse(m: inMat2d): Mat2d

If matrix determinant is zero the result is undefined.
def inverseTransformation(scale: inVec3d, rotation: inMat3d, translation: inVec3d): Mat4x3d

rotation
Must be an orthogonal matrix (matrix that represents an unscaled rotation) to achieve the desired result.
def inverseTransformation(scale: inVec2d, rotation: inMat2d, translation: inVec2d): Mat3x2d

rotation
Must be an orthogonal matrix (matrix that represents an unscaled rotation) to achieve the desired result.
def inversesqrt(u: inVec4d): Vec4d
def inversesqrt(u: inVec3d): Vec3d
def inversesqrt(u: inVec2d): Vec2d
def inversesqrt(x: Double): Double
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isinf(u: inVec4d): Vec4b
def isinf(u: inVec3d): Vec3b
def isinf(u: inVec2d): Vec2b
def isinf(x: Double): Boolean
def isnan(u: inVec4d): Vec4b
def isnan(u: inVec3d): Vec3b
def isnan(u: inVec2d): Vec2b
def isnan(x: Double): Boolean
def isneginf(x: Double): Boolean
def isnegzero(x: Double): Boolean
def isposinf(x: Double): Boolean
def isposzero(x: Double): Boolean
def length(u: inVec4d): Double
def length(u: inVec3d): Double
def length(u: inVec2d): Double
def length(x: Double): Double
final def length(u: inVec4i): Double
final def length(u: inVec3i): Double
final def length(u: inVec2i): Double
def lerp(m: inMat4d, n: inMat4d, a: Double): Mat4d
def lerp(m: inMat3x4d, n: inMat3x4d, a: Double): Mat3x4d
def lerp(m: inMat2x4d, n: inMat2x4d, a: Double): Mat2x4d
def lerp(m: inMat4x3d, n: inMat4x3d, a: Double): Mat4x3d
def lerp(m: inMat3d, n: inMat3d, a: Double): Mat3d
def lerp(m: inMat2x3d, n: inMat2x3d, a: Double): Mat2x3d
def lerp(m: inMat4x2d, n: inMat4x2d, a: Double): Mat4x2d
def lerp(m: inMat3x2d, n: inMat3x2d, a: Double): Mat3x2d
def lerp(m: inMat2d, n: inMat2d, a: Double): Mat2d
def lessThan(u: inVec4d, v: inVec4d): Vec4b
def lessThan(u: inVec3d, v: inVec3d): Vec3b
def lessThan(u: inVec2d, v: inVec2d): Vec2b
final def lessThan(u: inVec4i, v: inVec4i): Vec4b

Performs component-wise less than comparison.
Performs component-wise less than comparison.
u
an integer vector on the left-hand side of comparison.
v
an integer vector on the right-hand side of comparison.
returns
a boolean vector with components set to (u.c < v.c) for each component c.
final def lessThan(u: inVec3i, v: inVec3i): Vec3b

Performs component-wise less than comparison.
Performs component-wise less than comparison.
u
an integer vector on the left-hand side of comparison.
v
an integer vector on the right-hand side of comparison.
returns
a boolean vector with components set to (u.c < v.c) for each component c.
final def lessThan(u: inVec2i, v: inVec2i): Vec2b

Performs component-wise less than comparison.
Performs component-wise less than comparison.
u
an integer vector on the left-hand side of comparison.
v
an integer vector on the right-hand side of comparison.
returns
a boolean vector with components set to (u.c < v.c) for each component c.
def lessThanEqual(u: inVec4d, v: inVec4d): Vec4b
def lessThanEqual(u: inVec3d, v: inVec3d): Vec3b
def lessThanEqual(u: inVec2d, v: inVec2d): Vec2b
final def lessThanEqual(u: inVec4i, v: inVec4i): Vec4b

Performs component-wise less than or equal comparison.
Performs component-wise less than or equal comparison.
u
an integer vector on the left-hand side of comparison.
v
an integer vector on the right-hand side of comparison.
returns
a boolean vector with components set to (u.c <= v.c) for each component c.
final def lessThanEqual(u: inVec3i, v: inVec3i): Vec3b

Performs component-wise less than or equal comparison.
Performs component-wise less than or equal comparison.
u
an integer vector on the left-hand side of comparison.
v
an integer vector on the right-hand side of comparison.
returns
a boolean vector with components set to (u.c <= v.c) for each component c.
final def lessThanEqual(u: inVec2i, v: inVec2i): Vec2b

Performs component-wise less than or equal comparison.
Performs component-wise less than or equal comparison.
u
an integer vector on the left-hand side of comparison.
v
an integer vector on the right-hand side of comparison.
returns
a boolean vector with components set to (u.c <= v.c) for each component c.
def log(u: inVec4d): Vec4d
def log(u: inVec3d): Vec3d
def log(u: inVec2d): Vec2d
def log(x: Double): Double
def log2(u: inVec4d): Vec4d
def log2(u: inVec3d): Vec3d
def log2(u: inVec2d): Vec2d
def log2(x: Double): Double
def lookAt(direction: inVec3d, up: inVec3d): Mat3d
def matrixCompMult(a: inMat4d, b: inMat4d): Mat4d
def matrixCompMult(a: inMat3x4d, b: inMat3x4d): Mat3x4d
def matrixCompMult(a: inMat2x4d, b: inMat2x4d): Mat2x4d
def matrixCompMult(a: inMat4x3d, b: inMat4x3d): Mat4x3d
def matrixCompMult(a: inMat3d, b: inMat3d): Mat3d
def matrixCompMult(a: inMat2x3d, b: inMat2x3d): Mat2x3d
def matrixCompMult(a: inMat4x2d, b: inMat4x2d): Mat4x2d
def matrixCompMult(a: inMat3x2d, b: inMat3x2d): Mat3x2d
def matrixCompMult(a: inMat2d, b: inMat2d): Mat2d
def max(u: inVec4d, v: inVec4d): Vec4d
def max(u: inVec4d, s: Double): Vec4d
def max(u: inVec3d, v: inVec3d): Vec3d
def max(u: inVec3d, s: Double): Vec3d
def max(u: inVec2d, v: inVec2d): Vec2d
def max(u: inVec2d, s: Double): Vec2d
def max(x: Double, y: Double): Double
final def max(u: inVec4i, v: inVec4i): Vec4i

Applies max function to each component.
Applies max function to each component.
u
an integer vector argument.
v
an integer vector argument.
returns
a vector with components set to max(u.c, v.c) for each component c.
final def max(u: inVec4i, s: Int): Vec4i

Applies max function to each component.
Applies max function to each component.
u
an integer vector argument.
returns
a vector with components set to max(c, s) for each component c.
final def max(u: inVec3i, v: inVec3i): Vec3i

Applies max function to each component.
Applies max function to each component.
u
an integer vector argument.
v
an integer vector argument.
returns
a vector with components set to max(u.c, v.c) for each component c.
final def max(u: inVec3i, s: Int): Vec3i

Applies max function to each component.
Applies max function to each component.
u
an integer vector argument.
returns
a vector with components set to max(c, s) for each component c.
final def max(u: inVec2i, v: inVec2i): Vec2i

Applies max function to each component.
Applies max function to each component.
u
an integer vector argument.
v
an integer vector argument.
returns
a vector with components set to max(u.c, v.c) for each component c.
final def max(u: inVec2i, s: Int): Vec2i

Applies max function to each component.
Applies max function to each component.
u
an integer vector argument.
returns
a vector with components set to max(c, s) for each component c.
final def max(x: Int, y: Int): Int

Returns the larger one of two arguments.
Returns the larger one of two arguments.
x
an integer argument.
y
an integer argument.
returns
the largest argument.
def min(u: inVec4d, v: inVec4d): Vec4d
def min(u: inVec4d, s: Double): Vec4d
def min(u: inVec3d, v: inVec3d): Vec3d
def min(u: inVec3d, s: Double): Vec3d
def min(u: inVec2d, v: inVec2d): Vec2d
def min(u: inVec2d, s: Double): Vec2d
def min(x: Double, y: Double): Double
final def min(u: inVec4i, v: inVec4i): Vec4i

Applies min function to each component.
Applies min function to each component.
u
an integer vector argument.
v
an integer vector argument.
returns
a vector with components set to min(u.c, v.c) for each component c.
final def min(u: inVec4i, s: Int): Vec4i

Applies min function to each component.
Applies min function to each component.
u
an integer vector argument.
returns
a vector with components set to min(c, s) for each component c.
final def min(u: inVec3i, v: inVec3i): Vec3i

Applies min function to each component.
Applies min function to each component.
u
an integer vector argument.
v
an integer vector argument.
returns
a vector with components set to min(u.c, v.c) for each component c.
final def min(u: inVec3i, s: Int): Vec3i

Applies min function to each component.
Applies min function to each component.
u
an integer vector argument.
returns
a vector with components set to min(c, s) for each component c.
final def min(u: inVec2i, v: inVec2i): Vec2i

Applies min function to each component.
Applies min function to each component.
u
an integer vector argument.
v
an integer vector argument.
returns
a vector with components set to min(u.c, v.c) for each component c.
final def min(u: inVec2i, s: Int): Vec2i

Applies min function to each component.
Applies min function to each component.
u
an integer vector argument.
returns
a vector with components set to min(c, s) for each component c.
final def min(x: Int, y: Int): Int

Returns the smaller one of two arguments.
Returns the smaller one of two arguments.
x
an integer argument.
y
an integer argument.
returns
the smallest argument.
def mix(u: inVec4d, v: inVec4d, a: inVec4b): Vec4d
def mix(u: inVec4d, v: inVec4d, a: inVec4d): Vec4d
def mix(u: inVec4d, v: inVec4d, a: Double): Vec4d
def mix(u: inVec3d, v: inVec3d, a: inVec3b): Vec3d
def mix(u: inVec3d, v: inVec3d, a: inVec3d): Vec3d
def mix(u: inVec3d, v: inVec3d, a: Double): Vec3d
def mix(u: inVec2d, v: inVec2d, a: inVec2b): Vec2d
def mix(u: inVec2d, v: inVec2d, a: inVec2d): Vec2d
def mix(u: inVec2d, v: inVec2d, a: Double): Vec2d
def mix(x: Double, y: Double, a: Double): Double
def mod(u: inVec4d, v: inVec4d): Vec4d
def mod(u: inVec4d, s: Double): Vec4d
def mod(u: inVec3d, v: inVec3d): Vec3d
def mod(u: inVec3d, s: Double): Vec3d
def mod(u: inVec2d, v: inVec2d): Vec2d
def mod(u: inVec2d, s: Double): Vec2d
def mod(x: Double, y: Double): Double

Equivalent to x - y*floor(x/y)
def modf(u: inVec4d, i: Vec4d): Vec4d
def modf(u: inVec3d, i: Vec3d): Vec3d
def modf(u: inVec2d, i: Vec2d): Vec2d

Separates each component of a given vector into fractional and integer parts, both parts will have the same sign as the component.
Separates each component of a given vector into fractional and integer parts, both parts will have the same sign as the component.
u
the vector to be separated into fractional and integer parts.
i
a result vector to store the integer parts of components of u.
returns
a vector with fractional parts of components of u.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def norm(q: inQuat4d): Double
def normSquare(q: inQuat4d): Double
def normalMat(modelViewMatrix: inMat4x3d): Mat3d

Computes normal matrix.
Computes normal matrix.
modelViewMatrix
Model View Matrix.
def normalize(q: inQuat4d): Quat4d
def normalize(u: inVec4d): Vec4d
def normalize(u: inVec3d): Vec3d
def normalize(u: inVec2d): Vec2d
def normalize(x: Double): Double
def notEqual(u: inVec4d, v: inVec4d): Vec4b
def notEqual(u: inVec3d, v: inVec3d): Vec3b
def notEqual(u: inVec2d, v: inVec2d): Vec2b
final def notEqual(u: inVec4i, v: inVec4i): Vec4b

Performs component-wise not equal comparison.
Performs component-wise not equal comparison.
u
an integer vector on the left-hand side of comparison.
v
an integer vector on the right-hand side of comparison.
returns
a boolean vector with components set to (u.c != v.c) for each component c.
final def notEqual(u: inVec3i, v: inVec3i): Vec3b

Performs component-wise not equal comparison.
Performs component-wise not equal comparison.
u
an integer vector on the left-hand side of comparison.
v
an integer vector on the right-hand side of comparison.
returns
a boolean vector with components set to (u.c != v.c) for each component c.
final def notEqual(u: inVec2i, v: inVec2i): Vec2b

Performs component-wise not equal comparison.
Performs component-wise not equal comparison.
u
an integer vector on the left-hand side of comparison.
v
an integer vector on the right-hand side of comparison.
returns
a boolean vector with components set to (u.c != v.c) for each component c.
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def orthoProj(left: Double, right: Double, bottom: Double, top: Double, near: Double, far: Double): Mat4d

left
the coordinates of the left clipping plane.
right
the coordinates of the right clipping plane.
bottom
the coordinates of the bottom clipping plane.
top
the coordinates of the top clipping plane.
near
the distance to the near clipping plane, negative if the plane is behind the viewer.
far
the distance to the far clipping plane, negative if the plane is behind the viewer.
def outerProduct(c: inVec4d, r: inVec4d): Mat4d
def outerProduct(c: inVec4d, r: inVec3d): Mat3x4d
def outerProduct(c: inVec4d, r: inVec2d): Mat2x4d
def outerProduct(c: inVec3d, r: inVec4d): Mat4x3d
def outerProduct(c: inVec3d, r: inVec3d): Mat3d
def outerProduct(c: inVec3d, r: inVec2d): Mat2x3d
def outerProduct(c: inVec2d, r: inVec4d): Mat4x2d
def outerProduct(c: inVec2d, r: inVec3d): Mat3x2d
def outerProduct(c: inVec2d, r: inVec2d): Mat2d
def perspectiveProj(left: Double, right: Double, bottom: Double, top: Double, near: Double, far: Double): Mat4d

left
the coordinates of the left clipping plane.
right
the coordinates of the right clipping plane.
bottom
the coordinates of the bottom clipping plane.
top
the coordinates of the top clipping plane.
near
the distance to the near clipping plane, must be positive, approximately log2(far/near) bits of depth buffer precision are lost.
far
the distance to the far clipping plane, must be positive.
def perspectiveProj(fieldOfView: Double, aspectRatio: Double, near: Double, far: Double): Mat4d

fieldOfView
field of view angle in y direction, in radians.
aspectRatio
width/height aspect ratio.
near
the distance to the near clipping plane, must be positive, approximately log2(far/near) bits of depth buffer precision are lost.
far
the distance to the far clipping plane, must be positive.
def pow(u: inVec4d, v: inVec4d): Vec4d
def pow(u: inVec3d, v: inVec3d): Vec3d
def pow(u: inVec2d, v: inVec2d): Vec2d
def pow(x: Double, y: Double): Double
def quaternion(angle: Double, axis: inVec3d): Quat4d

The axis must have unit length to achieve the desired result.
def quaternion(m: inMat3d): Quat4d

The matrix must represent non-scaling rotation to achieve the desired result.
def radians(u: inVec4d): Vec4d
def radians(u: inVec3d): Vec3d
def radians(u: inVec2d): Vec2d
def radians(x: Double): Double
def reflect(i: inVec4d, n: inVec4d): Vec4d
def reflect(i: inVec3d, n: inVec3d): Vec3d
def reflect(i: inVec2d, n: inVec2d): Vec2d
def reflect(i: Double, n: Double): Double
def refract(i: inVec4d, n: inVec4d, eta: Double): Vec4d
def refract(i: inVec3d, n: inVec3d, eta: Double): Vec3d
def refract(i: inVec2d, n: inVec2d, eta: Double): Vec2d
def refract(i: Double, n: Double, eta: Double): Double
def rotateVector(u: inVec3d, q: inQuat4d): Vec3d

The quaternion must have unit norm to achieve the desired result.
def rotationAngle(m: inMat2d): Double

The matrix must represent non-scaling rotation to achieve the desired result.
def rotationMat(angle: Double, axis: inVec3d): Mat3d

The axis must have unit length to achieve the desired result.
def rotationMat(q: inQuat4d): Mat3d

The quaternion must have unit norm to achieve the desired result.
def rotationMat(angle: Double): Mat2d

This method creates a 2d transformation matrix that rotates a vector counterclockwise by the specified angle.
def round(u: inVec4d): Vec4d
def round(u: inVec3d): Vec3d
def round(u: inVec2d): Vec2d
def round(x: Double): Double
def roundEven(u: inVec4d): Vec4d
def roundEven(u: inVec3d): Vec3d
def roundEven(u: inVec2d): Vec2d
def roundEven(x: Double): Double
def sign(u: inVec4d): Vec4d
def sign(u: inVec3d): Vec3d
def sign(u: inVec2d): Vec2d
def sign(x: Double): Double
final def sign(u: inVec4i): Vec4i

Applies sign function to each component.
Applies sign function to each component.
u
an integer vector argument.
returns
a vector with components set to sign(u.c) for each component c.
final def sign(u: inVec3i): Vec3i

Applies sign function to each component.
Applies sign function to each component.
u
an integer vector argument.
returns
a vector with components set to sign(u.c) for each component c.
final def sign(u: inVec2i): Vec2i

Applies sign function to each component.
Applies sign function to each component.
u
an integer vector argument.
returns
a vector with components set to sign(u.c) for each component c.
final def sign(x: Int): Int

Returns the sign of the argument.
Returns the sign of the argument.
x
an integer argument.
returns
one of the following:
- -1 if x < 0.
- 1 if x > 0.
- 0 otherwise.
def sin(u: inVec4d): Vec4d
def sin(u: inVec3d): Vec3d
def sin(u: inVec2d): Vec2d
def sin(w: Double): Double
def sinh(u: inVec4d): Vec4d
def sinh(u: inVec3d): Vec3d
def sinh(u: inVec2d): Vec2d
def sinh(x: Double): Double
def slerp(p: inQuat4d, q: inQuat4d, a: Double): Quat4d
def smootherstep(edge0: inVec4d, edge1: inVec4d, u: inVec4d): Vec4d
def smootherstep(edge0: inVec3d, edge1: inVec3d, u: inVec3d): Vec3d
def smootherstep(edge0: inVec2d, edge1: inVec2d, u: inVec2d): Vec2d
def smootherstep(edge0: Double, edge1: Double, u: inVec4d): Vec4d
def smootherstep(edge0: Double, edge1: Double, u: inVec3d): Vec3d
def smootherstep(edge0: Double, edge1: Double, u: inVec2d): Vec2d
def smootherstep(edge0: Double, edge1: Double, x: Double): Double
def smoothstep(edge0: inVec4d, edge1: inVec4d, u: inVec4d): Vec4d
def smoothstep(edge0: Double, edge1: Double, u: inVec4d): Vec4d
def smoothstep(edge0: inVec3d, edge1: inVec3d, u: inVec3d): Vec3d
def smoothstep(edge0: Double, edge1: Double, u: inVec3d): Vec3d
def smoothstep(edge0: inVec2d, edge1: inVec2d, u: inVec2d): Vec2d
def smoothstep(edge0: Double, edge1: Double, u: inVec2d): Vec2d
def smoothstep(edge0: Double, edge1: Double, x: Double): Double
def sqrt(u: inVec4d): Vec4d
def sqrt(u: inVec3d): Vec3d
def sqrt(u: inVec2d): Vec2d
def sqrt(x: Double): Double
def step(edge: inVec4d, u: inVec4d): Vec4d
def step(edge: Double, u: inVec4d): Vec4d
def step(edge: inVec3d, u: inVec3d): Vec3d
def step(edge: Double, u: inVec3d): Vec3d
def step(edge: inVec2d, u: inVec2d): Vec2d
def step(edge: Double, u: inVec2d): Vec2d
def step(edge: Double, x: Double): Double
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tan(u: inVec4d): Vec4d
def tan(u: inVec3d): Vec3d
def tan(u: inVec2d): Vec2d
def tan(w: Double): Double
def tanh(u: inVec4d): Vec4d
def tanh(u: inVec3d): Vec3d
def tanh(u: inVec2d): Vec2d
def tanh(x: Double): Double
def toString(): String

Definition Classes
AnyRef → Any
def transformation(scale: inVec3d, rotation: inMat3d, translation: inVec3d): Mat4x3d
def transformation(scale: inVec2d, rotation: inMat2d, translation: inVec2d): Mat3x2d
def transpose(a: inMat4d): Mat4d
def transpose(a: inMat4x3d): Mat3x4d
def transpose(a: inMat4x2d): Mat2x4d
def transpose(a: inMat3x4d): Mat4x3d
def transpose(a: inMat3d): Mat3d
def transpose(a: inMat3x2d): Mat2x3d
def transpose(a: inMat2x4d): Mat4x2d
def transpose(a: inMat2x3d): Mat3x2d
def transpose(a: inMat2d): Mat2d
def trunc(u: inVec4d): Vec4d
def trunc(u: inVec3d): Vec3d
def trunc(u: inVec2d): Vec2d
def trunc(x: Double): Double
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws()

object functions

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final val E: Double(2.718281828459045)

final val Epsilon: Double(2.220446049250313E-16)

final val Pi: Double(3.141592653589793)

def abs(u: inVec4d): Vec4d

def abs(u: inVec3d): Vec3d

def abs(u: inVec2d): Vec2d

def abs(x: Double): Double

final def abs(u: inVec4i): Vec4i

final def abs(u: inVec3i): Vec3i

final def abs(u: inVec2i): Vec2i

final def abs(x: Int): Int

def acos(u: inVec4d): Vec4d

def acos(u: inVec3d): Vec3d

def acos(u: inVec2d): Vec2d

def acos(w: Double): Double

def acosh(u: inVec4d): Vec4d

def acosh(u: inVec3d): Vec3d

def acosh(u: inVec2d): Vec2d

def acosh(x: Double): Double

def angleAxis(m: inMat3d, axis: Vec3d): Double

def angleAxis(q: inQuat4d, axis: Vec3d): Double

def approxEqual(m: inMat4d, n: inMat4d, absDelta: Double): Boolean

def approxEqual(m: inMat3x4d, n: inMat3x4d, absDelta: Double): Boolean

def approxEqual(m: inMat2x4d, n: inMat2x4d, absDelta: Double): Boolean

def approxEqual(m: inMat4x3d, n: inMat4x3d, absDelta: Double): Boolean

def approxEqual(m: inMat3d, n: inMat3d, absDelta: Double): Boolean

def approxEqual(m: inMat2x3d, n: inMat2x3d, absDelta: Double): Boolean

def approxEqual(m: inMat4x2d, n: inMat4x2d, absDelta: Double): Boolean

def approxEqual(m: inMat3x2d, n: inMat3x2d, absDelta: Double): Boolean

def approxEqual(m: inMat2d, n: inMat2d, absDelta: Double): Boolean

def approxEqual(p: inQuat4d, q: inQuat4d, absDelta: Double): Boolean

def approxEqual(u: inVec4d, v: inVec4d, absDelta: Double): Boolean

def approxEqual(u: inVec3d, v: inVec3d, absDelta: Double): Boolean

def approxEqual(u: inVec2d, v: inVec2d, absDelta: Double): Boolean

def approxEqual(x: Double, y: Double, absDelta: Double): Boolean

final def asInstanceOf[T0]: T0

def asin(u: inVec4d): Vec4d

def asin(u: inVec3d): Vec3d

def asin(u: inVec2d): Vec2d

def asin(w: Double): Double

def asinh(u: inVec4d): Vec4d

def asinh(u: inVec3d): Vec3d

def asinh(u: inVec2d): Vec2d

def asinh(x: Double): Double

def atan(u: inVec4d): Vec4d

def atan(uy: inVec4d, ux: inVec4d): Vec4d

def atan(u: inVec3d): Vec3d

def atan(uy: inVec3d, ux: inVec3d): Vec3d

def atan(u: inVec2d): Vec2d

def atan(uy: inVec2d, ux: inVec2d): Vec2d

def atan(w: Double): Double

def atan(y: Double, x: Double): Double

def atanh(u: inVec4d): Vec4d

def atanh(u: inVec3d): Vec3d

def atanh(u: inVec2d): Vec2d

def atanh(x: Double): Double

def ceil(u: inVec4d): Vec4d

def ceil(u: inVec3d): Vec3d

def ceil(u: inVec2d): Vec2d

def ceil(x: Double): Double

def clamp(u: inVec4d, minVal: inVec4d, maxVal: inVec4d): Vec4d

def clamp(u: inVec4d, minVal: Double, maxVal: Double): Vec4d

def clamp(u: inVec3d, minVal: inVec3d, maxVal: inVec3d): Vec3d

def clamp(u: inVec3d, minVal: Double, maxVal: Double): Vec3d

def clamp(u: inVec2d, minVal: inVec2d, maxVal: inVec2d): Vec2d

def clamp(u: inVec2d, minVal: Double, maxVal: Double): Vec2d

def clamp(x: Double, minVal: Double, maxVal: Double): Double

final def clamp(u: inVec4i, minVal: inVec4i, maxVal: inVec4i): Vec4i

final def clamp(u: inVec4i, minVal: Int, maxVal: Int): Vec4i

final def clamp(u: inVec3i, minVal: inVec3i, maxVal: inVec3i): Vec3i

final def clamp(u: inVec3i, minVal: Int, maxVal: Int): Vec3i

final def clamp(u: inVec2i, minVal: inVec2i, maxVal: inVec2i): Vec2i