Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## shout3d.math
Class MatUtil

    java.lang.Object
      |
      +--shout3d.math.MatUtil

public class MatUtil
extends java.lang.Object

Matrix and rotation Utility Methods

Constructor Summary
`MatUtil()`

Method Summary
`static void` | `axisToQuat(float[] fromAA, float[] toQuat)` convert an axis/angle rotation into a quaternion rotation.
`static void` | `composeQuats(float[] q1, float[] q2, float[] composedQuat)` Creates a third quaternion that is equivalent to the first followed by the second
`static float` | `dot(float[] v1, float[] v2)` Calculates the dot product of two 3-vectors
`static float[]` | `getMatrixAlongPath(Node[] path, boolean bottomToTop)` Gets the matrix equivalent to concatenating all the matrices along the given path.
`static void` | `multDirMatrix(float[] mtx, float[] v)` Transforms a direction by a 4x4 matrix.
`static float[]` | `multMatrix44byMatrix44(float[] mat1, float[] mat2)` Multiplies two 4x4 matrices, stores the result in the first, and returns that first matrix.
`static void` | `multVecMatrix(float[] mtx, float[] v)` Transforms a point by a 4x4 matrix
`static float` | `normalize(float[] v)` Normalizes the given vector.
`static void` | `quatToAxis(float[] fromQuat, float[] toAA)` convert a quaternion rotation into an axis/angle rotation.
`static void` | `setToIdentityMatrix44(float[] mtx)` Set a 4x4 matrix to be an identity matrix

Methods inherited from class java.lang.Object
`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### MatUtil

    public MatUtil()

Method Detail

### setToIdentityMatrix44

    public static final void setToIdentityMatrix44(float[] mtx)

  Set a 4x4 matrix to be an identity matrix
  Parameters:
    `mtx` - the transformation matrix

### multVecMatrix

    public static final void multVecMatrix(float[] mtx,
                                           float[] v)

  Transforms a point by a 4x4 matrix
  Parameters:
    `mtx` - the transformation matrix
    `v` - the point to transform, answer returned in the point

### multDirMatrix

    public static final void multDirMatrix(float[] mtx,
                                           float[] v)

  Transforms a direction by a 4x4 matrix. Skips the addition of the 4th row, which translates Does NOT normalize the result
  Parameters:
    `mtx` - the transformation matrix
    `v` - the direction to transform, answer returned in the point

### normalize

    public static final float normalize(float[] v)

  Normalizes the given vector. Returns the length prior to being normalized.
  Parameters:
    `v` - the vector to normalize
  Returns:
    the length of the vector prior to normalization.

### dot

    public static final float dot(float[] v1,
                                  float[] v2)

  Calculates the dot product of two 3-vectors
  Parameters:
    `v1` - the first vector
    `v2` - the second vector
  Returns:
    the dot product

### quatToAxis

    public static final void quatToAxis(float[] fromQuat,
                                        float[] toAA)

  convert a quaternion rotation into an axis/angle rotation. The axis is stored in the 1st three elements, the angle in the fourth Okay to send the same reference in both arguments
  Parameters:
    `fromQuat` - the quaternion to convert
    `toAA` - the result axis/angle rotation

### axisToQuat

    public static final void axisToQuat(float[] fromAA,
                                        float[] toQuat)

  convert an axis/angle rotation into a quaternion rotation. The axis is stored in the 1st three elements, the angle in the fourth Okay to send the same reference in both arguments
  Parameters:
    `fromAA` - the axis/angle to convert
    `toQuat` - the result quaternion rotation

### composeQuats

    public static final void composeQuats(float[] q1,
                                          float[] q2,
                                          float[] composedQuat)

  Creates a third quaternion that is equivalent to the first followed by the second
  Parameters:
    `q1` - the first quaternion to compose
    `q2` - the second quaternion to compose
    `composedQuat` - the result of composing q1 and q2

### multMatrix44byMatrix44

    public static final float[] multMatrix44byMatrix44(float[] mat1,
                                                       float[] mat2)

  Multiplies two 4x4 matrices, stores the result in the first, and returns that first matrix. return( mat1 = [mat1][mat2]

### getMatrixAlongPath

    public static float[] getMatrixAlongPath(Node[] path,
                                             boolean bottomToTop)

  Gets the matrix equivalent to concatenating all the matrices along the given path. If bottomToTop is true, then the matrix will transform from the local space at the end of the path to the space at the top of the path. If bottomToTop is false, then the matrix will transform from the space at the top of the path to the local space of the node at the bottom of the path.
  Parameters:
    `the` - path along which to calculate the matrix
    `bottomToTop` - whether the matrix transforms from bottom space to top space or vice versa
  Returns:
    the matrix along the path.

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD