processing.core

## Class PMatrix3D

- Object
- - PMatrix3D

- All Implemented Interfaces:
    PMatrix

      public final class PMatrix3D
      extends Object
      implements PMatrix

  4x4 matrix implementation.

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `float` | `m00`
    `float` | `m01`
    `float` | `m02`
    `float` | `m03`
    `float` | `m10`
    `float` | `m11`
    `float` | `m12`
    `float` | `m13`
    `float` | `m20`
    `float` | `m21`
    `float` | `m22`
    `float` | `m23`
    `float` | `m30`
    `float` | `m31`
    `float` | `m32`
    `float` | `m33`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `PMatrix3D()`
    `PMatrix3D(float m00, float m01, float m02, float m10, float m11, float m12)`
    `PMatrix3D(float m00, float m01, float m02, float m03, float m10, float m11, float m12, float m13, float m20, float m21, float m22, float m23, float m30, float m31, float m32, float m33)`
    `PMatrix3D(PMatrix matrix)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `apply(float n00, float n01, float n02, float n10, float n11, float n12)`
    `void` | `apply(float n00, float n01, float n02, float n03, float n10, float n11, float n12, float n13, float n20, float n21, float n22, float n23, float n30, float n31, float n32, float n33)`
    `void` | `apply(PMatrix source)` Multiply this matrix by another.
    `void` | `apply(PMatrix2D source)`
    `void` | `apply(PMatrix3D source)`
    `float` | `determinant()`
    `PMatrix3D` | `get()` Returns a copy of this PMatrix.
    `float[]` | `get(float[] target)` Copies the matrix contents into a 16 entry float array.
    `boolean` | `invert()` Invert this matrix.
    `float[]` | `mult(float[] source, float[] target)` Multiply a three or four element vector against this matrix.
    `PVector` | `mult(PVector source, PVector target)` Multiply a PVector by this matrix.
    `float` | `multW(float x, float y, float z)`
    `float` | `multW(float x, float y, float z, float w)`
    `float` | `multX(float x, float y)`
    `float` | `multX(float x, float y, float z)`
    `float` | `multX(float x, float y, float z, float w)`
    `float` | `multY(float x, float y)`
    `float` | `multY(float x, float y, float z)`
    `float` | `multY(float x, float y, float z, float w)`
    `float` | `multZ(float x, float y, float z)`
    `float` | `multZ(float x, float y, float z, float w)`
    `void` | `preApply(float n00, float n01, float n02, float n10, float n11, float n12)`
    `void` | `preApply(float n00, float n01, float n02, float n03, float n10, float n11, float n12, float n13, float n20, float n21, float n22, float n23, float n30, float n31, float n32, float n33)`
    `void` | `preApply(PMatrix source)` Apply another matrix to the left of this one.
    `void` | `preApply(PMatrix2D left)`
    `void` | `preApply(PMatrix3D left)`
    `void` | `print()`
    `void` | `reset()`
    `void` | `rotate(float angle)`
    `void` | `rotate(float angle, float v0, float v1, float v2)`
    `void` | `rotateX(float angle)`
    `void` | `rotateY(float angle)`
    `void` | `rotateZ(float angle)`
    `void` | `scale(float s)`
    `void` | `scale(float sx, float sy)`
    `void` | `scale(float x, float y, float z)`
    `void` | `set(float[] source)`
    `void` | `set(float m00, float m01, float m02, float m10, float m11, float m12)`
    `void` | `set(float m00, float m01, float m02, float m03, float m10, float m11, float m12, float m13, float m20, float m21, float m22, float m23, float m30, float m31, float m32, float m33)`
    `void` | `set(PMatrix matrix)`
    `void` | `shearX(float angle)`
    `void` | `shearY(float angle)`
    `void` | `translate(float tx, float ty)`
    `void` | `translate(float tx, float ty, float tz)`
    `void` | `transpose()` Transpose this matrix.

    - ### Methods inherited from class Object

      `equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### m00

          public float m00

    - #### m01

          public float m01

    - #### m02

          public float m02

    - #### m03

          public float m03

    - #### m10

          public float m10

    - #### m11

          public float m11

    - #### m12

          public float m12

    - #### m13

          public float m13

    - #### m20

          public float m20

    - #### m21

          public float m21

    - #### m22

          public float m22

    - #### m23

          public float m23

    - #### m30

          public float m30

    - #### m31

          public float m31

    - #### m32

          public float m32

    - #### m33

          public float m33

  - ### Constructor Detail

    - #### PMatrix3D

          public PMatrix3D()

    - #### PMatrix3D

          public PMatrix3D(float m00,
                           float m01,
                           float m02,
                           float m10,
                           float m11,
                           float m12)

    - #### PMatrix3D

          public PMatrix3D(float m00,
                           float m01,
                           float m02,
                           float m03,
                           float m10,
                           float m11,
                           float m12,
                           float m13,
                           float m20,
                           float m21,
                           float m22,
                           float m23,
                           float m30,
                           float m31,
                           float m32,
                           float m33)

    - #### PMatrix3D

          public PMatrix3D(PMatrix matrix)

  - ### Method Detail

    - #### reset

          public void reset()

      Specified by:
        `reset` in interface `PMatrix`

    - #### get

          public PMatrix3D get()

      Returns a copy of this PMatrix.
      Specified by:
        `get` in interface `PMatrix`

    - #### get

          public float[] get(float[] target)

      Copies the matrix contents into a 16 entry float array. If target is null (or not the correct size), a new array will be created.
      Specified by:
        `get` in interface `PMatrix`

    - #### set

          public void set(PMatrix matrix)

      Specified by:
        `set` in interface `PMatrix`

    - #### set

          public void set(float[] source)

      Specified by:
        `set` in interface `PMatrix`

    - #### set

          public void set(float m00,
                          float m01,
                          float m02,
                          float m10,
                          float m11,
                          float m12)

      Specified by:
        `set` in interface `PMatrix`

    - #### set

          public void set(float m00,
                          float m01,
                          float m02,
                          float m03,
                          float m10,
                          float m11,
                          float m12,
                          float m13,
                          float m20,
                          float m21,
                          float m22,
                          float m23,
                          float m30,
                          float m31,
                          float m32,
                          float m33)

      Specified by:
        `set` in interface `PMatrix`

    - #### translate

          public void translate(float tx,
                                float ty)

      Specified by:
        `translate` in interface `PMatrix`

    - #### translate

          public void translate(float tx,
                                float ty,
                                float tz)

      Specified by:
        `translate` in interface `PMatrix`

    - #### rotate

          public void rotate(float angle)

      Specified by:
        `rotate` in interface `PMatrix`

    - #### rotateX

          public void rotateX(float angle)

      Specified by:
        `rotateX` in interface `PMatrix`

    - #### rotateY

          public void rotateY(float angle)

      Specified by:
        `rotateY` in interface `PMatrix`

    - #### rotateZ

          public void rotateZ(float angle)

      Specified by:
        `rotateZ` in interface `PMatrix`

    - #### rotate

          public void rotate(float angle,
                             float v0,
                             float v1,
                             float v2)

      Specified by:
        `rotate` in interface `PMatrix`

    - #### scale

          public void scale(float s)

      Specified by:
        `scale` in interface `PMatrix`

    - #### scale

          public void scale(float sx,
                            float sy)

      Specified by:
        `scale` in interface `PMatrix`

    - #### scale

          public void scale(float x,
                            float y,
                            float z)

      Specified by:
        `scale` in interface `PMatrix`

    - #### shearX

          public void shearX(float angle)

      Specified by:
        `shearX` in interface `PMatrix`

    - #### shearY

          public void shearY(float angle)

      Specified by:
        `shearY` in interface `PMatrix`

    - #### apply

          public void apply(PMatrix source)

      Description copied from interface: `PMatrix`
      Multiply this matrix by another.
      Specified by:
        `apply` in interface `PMatrix`

    - #### apply

          public void apply(PMatrix2D source)

      Specified by:
        `apply` in interface `PMatrix`

    - #### apply

          public void apply(PMatrix3D source)

      Specified by:
        `apply` in interface `PMatrix`

    - #### apply

          public void apply(float n00,
                            float n01,
                            float n02,
                            float n10,
                            float n11,
                            float n12)

      Specified by:
        `apply` in interface `PMatrix`

    - #### apply

          public void apply(float n00,
                            float n01,
                            float n02,
                            float n03,
                            float n10,
                            float n11,
                            float n12,
                            float n13,
                            float n20,
                            float n21,
                            float n22,
                            float n23,
                            float n30,
                            float n31,
                            float n32,
                            float n33)

      Specified by:
        `apply` in interface `PMatrix`

    - #### preApply

          public void preApply(PMatrix2D left)

      Specified by:
        `preApply` in interface `PMatrix`

    - #### preApply

          public void preApply(PMatrix source)

      Apply another matrix to the left of this one.
      Specified by:
        `preApply` in interface `PMatrix`

    - #### preApply

          public void preApply(PMatrix3D left)

      Specified by:
        `preApply` in interface `PMatrix`

    - #### preApply

          public void preApply(float n00,
                               float n01,
                               float n02,
                               float n10,
                               float n11,
                               float n12)

      Specified by:
        `preApply` in interface `PMatrix`

    - #### preApply

          public void preApply(float n00,
                               float n01,
                               float n02,
                               float n03,
                               float n10,
                               float n11,
                               float n12,
                               float n13,
                               float n20,
                               float n21,
                               float n22,
                               float n23,
                               float n30,
                               float n31,
                               float n32,
                               float n33)

      Specified by:
        `preApply` in interface `PMatrix`

    - #### mult

          public PVector mult(PVector source,
                              PVector target)

      Description copied from interface: `PMatrix`
      Multiply a PVector by this matrix.
      Specified by:
        `mult` in interface `PMatrix`

    - #### mult

          public float[] mult(float[] source,
                              float[] target)

      Multiply a three or four element vector against this matrix. If out is null or not length 3 or 4, a new float array (length 3) will be returned.
      Specified by:
        `mult` in interface `PMatrix`

    - #### multX

          public float multX(float x,
                             float y)

    - #### multY

          public float multY(float x,
                             float y)

    - #### multX

          public float multX(float x,
                             float y,
                             float z)

    - #### multY

          public float multY(float x,
                             float y,
                             float z)

    - #### multZ

          public float multZ(float x,
                             float y,
                             float z)

    - #### multW

          public float multW(float x,
                             float y,
                             float z)

    - #### multX

          public float multX(float x,
                             float y,
                             float z,
                             float w)

    - #### multY

          public float multY(float x,
                             float y,
                             float z,
                             float w)

    - #### multZ

          public float multZ(float x,
                             float y,
                             float z,
                             float w)

    - #### multW

          public float multW(float x,
                             float y,
                             float z,
                             float w)

    - #### transpose

          public void transpose()

      Transpose this matrix.
      Specified by:
        `transpose` in interface `PMatrix`

    - #### invert

          public boolean invert()

      Invert this matrix.
      Specified by:
        `invert` in interface `PMatrix`
      Returns:
        true if successful

    - #### determinant

          public float determinant()

      Specified by:
        `determinant` in interface `PMatrix`
      Returns:
        the determinant of the matrix

    - #### print

          public void print()