Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * The MIT License (MIT)
   *
   * Copyright (c) 2014 Christian Gärtner
   *
   * Permission is hereby granted, free of charge, to any person obtaining a copy
   * of this software and associated documentation files (the "Software"), to deal
   * in the Software without restriction, including without limitation the rights
   * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  * copies of the Software, and to permit persons to whom the Software is
  * furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be included in all
  * copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
 
 package org.achtern.AchternEngine.core.math;

Implementation of the mathematical Matrix with 4x4 float values
 
 public class Matrix4f {

    
Main Data Array
 
     private float[][] m;

    
Initializes with 0
 
     public Matrix4f() {
          = new float[4][4];
     }

    
Initializes this matrix as identiy Matrix

Returns:
this
 
     public Matrix4f initIdentiy() {
 
         [0][0] = 1;    [0][1] = 0;    [0][2] = 0;    [0][3] = 0;
         [1][0] = 0;    [1][1] = 1;    [1][2] = 0;    [1][3] = 0;
         [2][0] = 0;    [2][1] = 0;    [2][2] = 1;    [2][3] = 0;
         [3][0] = 0;    [3][1] = 0;    [3][2] = 0;    [3][3] = 1;
 
         return this;
     }
 
     public Matrix4f initTranslation(float xfloat yfloat z) {
         [0][0] = 1;    [0][1] = 0;    [0][2] = 0;    [0][3] = x;
         [1][0] = 0;    [1][1] = 1;    [1][2] = 0;    [1][3] = y;
         [2][0] = 0;    [2][1] = 0;    [2][2] = 1;    [2][3] = z;
         [3][0] = 0;    [3][1] = 0;    [3][2] = 0;    [3][3] = 1;
 
         return this;
     }
 
     public Matrix4f initRotation(float xfloat yfloat z) {
 
         Matrix4f mx = new Matrix4f();
         Matrix4f my = new Matrix4f();
         Matrix4f mz = new Matrix4f();
 
         x = (float) Math.toRadians(x);
         y = (float) Math.toRadians(y);
         z = (float) Math.toRadians(z);
 
         mz.m[0][0] = (float) Math.cos(z);   mz.m[0][1] = (float) - Math.sin(z); mz.m[0][2] = 0;                     mz.m[0][3] = 0;
         mz.m[1][0] = (float) Math.sin(z);   mz.m[1][1] = (float) + Math.cos(z); mz.m[1][2] = 0;                     mz.m[1][3] = 0;
         mz.m[2][0] = 0;                     mz.m[2][1] = 0;                     mz.m[2][2] = 1;                     mz.m[2][3] = 0;
         mz.m[3][0] = 0;                     mz.m[3][1] = 0;                     mz.m[3][2] = 0;                     mz.m[3][3] = 1;
 
         mx.m[0][0] = 1;                     mx.m[0][1] = 0;                     mx.m[0][2] = 0;                     mx.m[0][3] = 0;
         mx.m[1][0] = 0;                     mx.m[1][1] = (float) Math.cos(x);   mx.m[1][2] = (float) - Math.sin(x); mx.m[1][3] = 0;
         mx.m[2][0] = 0;                     mx.m[2][1] = (float) Math.sin(x);   mx.m[2][2] = (float) + Math.cos(x); mx.m[2][3] = 0;
         mx.m[3][0] = 0;                     mx.m[3][1] = 0;                     mx.m[3][2] = 0;                     mx.m[3][3] = 1;
 
         my.m[0][0] = (float) Math.cos(y);   my.m[0][1] = 0;                     my.m[0][2] = (float) - Math.sin(y); my.m[0][3] = 0;
         my.m[1][0] = 0;                     my.m[1][1] = 1;                     my.m[1][2] = 0;                     my.m[1][3] = 0;
         my.m[2][0] = (float) Math.sin(y);   my.m[2][1] = 0;                     my.m[2][2] = (float) + Math.cos(y); my.m[2][3] = 0;
         my.m[3][0] = 0;                     my.m[3][1] = 0;                     my.m[3][2] = 0;                     my.m[3][3] = 1;
 
          = mz.mul(my.mul(mx)).getM();
 
         return this;
     }
 
     public Matrix4f initScale(float xfloat yfloat z) {
         [0][0] = x[1][0] = 0; [2][0] = 0; [3][0] = 0;
        [0][1] = 0; [1][1] = y[2][1] = 0; [3][1] = 0;
        [0][2] = 0; [1][2] = 0; [2][2] = z[3][2] = 0;
        [0][3] = 0; [1][3] = 0; [2][3] = 0; [3][3] = 1;
        return this;
    }
    public Matrix4f initPerspective(float fovfloat aspectfloat zNearfloat zFar) {
        float fgv = (float) Math.tan(fov / 2);
        float range = zNear - zFar;
        [0][0] = 1.0f / (fgv * aspect);  [0][1] = 0;               [0][2] = 0;                     [0][3] = 0;
        [1][0] = 0;                      [1][1] = 1.0f / (fgv);    [1][2] = 0;                     [1][3] = 0;
        [2][0] = 0;                      [2][1] = 0;               [2][2] = (-zNear - zFar)/range[2][3] = 2 * zFar * zNear / range;
        [3][0] = 0;                      [3][1] = 0;               [3][2] = 1;                     [3][3] = 0;
        return this;
    }
    public Matrix4f initOrthographic(float leftfloat rightfloat bottomfloat topfloat nearfloat far) {
        float RmL = right - left;
        float TmB = top - bottom;
        float FmN = far - near;
        float RpL = right + left;
        float TpB = top + bottom;
        float FpN = far + near;
        [0][0] = 2 / RmL;   [0][1] = 0;         [0][2] = 0;         [0][3] = - RpL / RmL;
        [1][0] = 0;         [1][1] = 2 / TmB;   [1][2] = 0;         [1][3] = - TpB / TmB;
        [2][0] = 0;         [2][1] = 0;         [2][2] = - 1 / FmN[2][3] = - near / FmN;
        [3][0] = 0;         [3][1] = 0;         [3][2] = 0;         [3][3] = 1;
        return this;
    }
    public Matrix4f initRotation(Vector3f forwardVector3f up) {
        Vector3f f = forward.normalized();
        Vector3f r = up.normalized().cross(f);
        Vector3f u = f.cross(r);
        return initRotation(fur);
    }
    public Matrix4f initRotation(Vector3f forwardVector3f upVector3f right) {
        [0][0] = right.getX();     [0][1] = right.getY();     [0][2] = right.getZ();    [0][3] = 0;
        [1][0] = up.getX();        [1][1] = up.getY();        [1][2] = up.getZ();       [1][3] = 0;
        [2][0] = forward.getX();   [2][1] = forward.getY();   [2][2] = forward.getZ();  [2][3] = 0;
        [3][0] = 0;                [3][1] = 0;                [3][2] = 0;               [3][3] = 1;
        return this;
    }
    public Vector3f transform(Vector3f v) {
        return new Vector3f(
                [0][0] * v.getX() + [0][1] * v.getY() + [0][2] * v.getZ() + [0][3],
                [1][0] * v.getX() + [1][1] * v.getY() + [1][2] * v.getZ() + [1][3],
                [2][0] * v.getX() + [2][1] * v.getY() + [2][2] * v.getZ() + [2][3]
        );
    }
    public Matrix4f mul(Matrix4f ma) {
        Matrix4f ret = new Matrix4f();
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                ret.set(ij[i][0] * ma.get(0, j) +
                              [i][1] * ma.get(1, j) +
                              [i][2] * ma.get(2, j) +
                              [i][3] * ma.get(3, j));
            }
        }
        return ret;
    }
    public float get(int xint y) {
        return [x][y];
    }
    public void set(int xint yfloat val) {
        [x][y] = val;
    }
    public void set1Line(float x1float x2float x3int x4) {
        [0][0] = x1;
        [0][1] = x2;
        [0][2] = x3;
        [0][3] = x4;
    }
    public void set2Line(float x1float x2float x3float x4) {
        [1][0] = x1;
        [1][1] = x2;
        [1][2] = x3;
        [1][3] = x4;
    }
    public void set3Line(float x1float x2float x3float x4) {
        [2][0] = x1;
        [2][1] = x2;
        [2][2] = x3;
        [2][3] = x4;
    }
    public void set4Line(float x1float x2float x3float x4) {
        [3][0] = x1;
        [3][1] = x2;
        [3][2] = x3;
        [3][3] = x4;
    }

    
Returns a copy of the array!

Returns:
copy
    public float[][] getM() {
        float[][] res = new float[4][4];
        System.arraycopy(, 0, res, 0, .);
        return res;
    }

    
Returns the array itself

Returns:
data array
    public float[][] getMReference() {
        return ;
    }
    public void setM(float[][] m) {
        this. = m;
    }
    @Override
    public String toString() {
        return "(" +
                "(" + get(0, 0) + "/" + get(0, 1) + "/" + get(0, 2) + "/" + get(0, 3) + ")," +
                "(" + get(1, 0) + "/" + get(1, 1) + "/" + get(1, 2) + "/" + get(1, 3) + ")," +
                "(" + get(2, 0) + "/" + get(2, 1) + "/" + get(2, 2) + "/" + get(2, 3) + ")," +
                "(" + get(3, 0) + "/" + get(3, 1) + "/" + get(3, 2) + "/" + get(3, 3) + ")," +
                ")";
    }
New to GrepCode? Check out our FAQ X