processing.core

## Interface PMatrix

- All Known Implementing Classes:
    PMatrix2D, PMatrix3D

      public interface PMatrix

- - ### Method Summary

    All Methods Instance Methods Abstract 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()`
    `PMatrix` | `get()` Returns a copy of this PMatrix.
    `float[]` | `get(float[] target)` Copies the matrix contents into a float array.
    `boolean` | `invert()` Invert this matrix.
    `float[]` | `mult(float[] source, float[] target)` Multiply a multi-element vector against this matrix.
    `PVector` | `mult(PVector source, PVector target)` Multiply a PVector by this matrix.
    `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 left)` Apply another matrix to the left of this one.
    `void` | `preApply(PMatrix2D left)`
    `void` | `preApply(PMatrix3D left)`
    `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 src)`
    `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.

- - ### Method Detail

    - #### reset

          void reset()

    - #### get

          PMatrix get()

      Returns a copy of this PMatrix.

    - #### get

          float[] get(float[] target)

      Copies the matrix contents into a float array. If target is null (or not the correct size), a new array will be created.

    - #### set

          void set(PMatrix src)

    - #### set

          void set(float[] source)

    - #### set

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

    - #### set

          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)

    - #### translate

          void translate(float tx,
                         float ty)

    - #### translate

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

    - #### rotate

          void rotate(float angle)

    - #### rotateX

          void rotateX(float angle)

    - #### rotateY

          void rotateY(float angle)

    - #### rotateZ

          void rotateZ(float angle)

    - #### rotate

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

    - #### scale

          void scale(float s)

    - #### scale

          void scale(float sx,
                     float sy)

    - #### scale

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

    - #### shearX

          void shearX(float angle)

    - #### shearY

          void shearY(float angle)

    - #### apply

          void apply(PMatrix source)

      Multiply this matrix by another.

    - #### apply

          void apply(PMatrix2D source)

    - #### apply

          void apply(PMatrix3D source)

    - #### apply

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

    - #### apply

          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)

    - #### preApply

          void preApply(PMatrix left)

      Apply another matrix to the left of this one.

    - #### preApply

          void preApply(PMatrix2D left)

    - #### preApply

          void preApply(PMatrix3D left)

    - #### preApply

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

    - #### preApply

          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)

    - #### mult

          PVector mult(PVector source,
                       PVector target)

      Multiply a PVector by this matrix.

    - #### mult

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

      Multiply a multi-element vector against this matrix.

    - #### transpose

          void transpose()

      Transpose this matrix.

    - #### invert

          boolean invert()

      Invert this matrix.
      Returns:
        true if successful

    - #### determinant

          float determinant()

      Returns:
        the determinant of the matrix