2015-05-14 82 views
0

執行4x4矩陣的翻譯可以說我有一個Matrix4f matrix,填充了我想用一個點來翻譯Vec3 translation = new Vec3(2.0f, 1.0f, 0.0f);由3元向量

下面的公式給了我意想不到的結果值,我怎麼能正確地翻譯我的矩陣的重點? e.g

Matrix4f result = Utils.translate(matrix, translation); 

這是我目前的翻譯代碼..

public Matrix4f translate(Matrix4f matrix, Vec3 vector) { 

    Matrix4f transform = new Matrix4f(new float[][] { 
      new float[] { 0, 0, 0, vector.x }, 
      new float[] { 0, 0, 0, vector.y }, 
      new float[] { 0, 0, 0, vector.z }, 
      new float[] { 0, 0, 0, 1 }, 
    }); 

    return add(matrix, transform); 
} 

public Matrix4f add(Matrix4f matrixA, Matrix4f matrixB) { 

    Matrix4f matrix = new Matrix4f(); 

    for (int a = 0; a < matrix.values.length; a++){ 
     matrix.values[a] = matrixA.values[a] + matrixB.values[a]; 
    } 

    return matrix; 
} 

public void loadIdentity(Matrix4f matrix) { 
    matrix.load(new float[][] { 
      new float[] { 1, 0, 0, 0 }, 
      new float[] { 0, 1, 0, 0 }, 
      new float[] { 0, 0, 1, 0 }, 
      new float[] { 0, 0, 0, 1 }, 
    }); 
} 

這是Matrix4f定義..

public class Matrix4f { 

    public float[] values; 

    public Matrix4f() { 
     this.values = new float[16]; 
     Utils.loadIdentity(this); 
    } 

    public Matrix4f(float[] values) { 
     this.values = values; 
    } 

    public Matrix4f(float[][] values) { 
     load(values); 
    } 

    public void load(float[][] values) { 
     this.values = new float[] { 
      values[0][0], values[0][1], values[0][2], values[0][3], 
      values[1][0], values[1][1], values[1][2], values[1][3], 
      values[2][0], values[2][1], values[2][2], values[2][3], 
      values[3][0], values[3][1], values[3][2], values[3][3] 
     }; 
    } 

    public float[] getValues() { 
    return this.values; 
    } 
} 
+0

爲什麼你只矩陣一維?另外,您的意外和預期結果是什麼? – GiantTree

+0

@GiantTree當我創建矩陣時,我最初用單位矩陣加載它作爲二維數組,但它的存儲爲1d。我不希望存儲機制造成問題,對吧? – bobbyrne01

+0

不,對我來說,調用一維數組*矩陣*看起來很奇怪,這並不是錯的,只是奇怪,因爲你用一個2維數組加載它。我會在一秒鐘內測試你的代碼。現在看起來對我來說很好。 – GiantTree

回答

0
public Matrix4f translate(Matrix4f matrix, Vec3 vector) { 

    Matrix4f transform = new Matrix4f(new float[][] { 
      new float[] { 1, 0, 0, vector.x }, 
      new float[] { 0, 1, 0, vector.y }, 
      new float[] { 0, 0, 1, vector.z }, 
      new float[] { 0, 0, 0, 1 }, 
    }); 

    return multiply(matrix, transform); 
} 

public Matrix4f multiply(Matrix4f matrixA, Matrix4f matrixB) { 

    Matrix4f matrix = new Matrix4f(new float[][] { 
      new float[] { 
        (matrixA.values[0] * matrixB.values[0]) + (matrixA.values[1] * matrixB.values[4]) + (matrixA.values[2] * matrixB.values[8]) + (matrixA.values[3] * matrixB.values[12]), 
        (matrixA.values[0] * matrixB.values[1]) + (matrixA.values[1] * matrixB.values[5]) + (matrixA.values[2] * matrixB.values[9]) + (matrixA.values[3] * matrixB.values[13]), 
        (matrixA.values[0] * matrixB.values[2]) + (matrixA.values[1] * matrixB.values[6]) + (matrixA.values[2] * matrixB.values[10]) + (matrixA.values[3] * matrixB.values[14]), 
        (matrixA.values[0] * matrixB.values[3]) + (matrixA.values[1] * matrixB.values[7]) + (matrixA.values[2] * matrixB.values[11]) + (matrixA.values[3] * matrixB.values[15]) 
      }, 
      new float[] { 
        (matrixA.values[4] * matrixB.values[0]) + (matrixA.values[5] * matrixB.values[4]) + (matrixA.values[6] * matrixB.values[8]) + (matrixA.values[7] * matrixB.values[12]), 
        (matrixA.values[4] * matrixB.values[1]) + (matrixA.values[5] * matrixB.values[5]) + (matrixA.values[6] * matrixB.values[9]) + (matrixA.values[7] * matrixB.values[13]), 
        (matrixA.values[4] * matrixB.values[2]) + (matrixA.values[5] * matrixB.values[6]) + (matrixA.values[6] * matrixB.values[10]) + (matrixA.values[7] * matrixB.values[14]), 
        (matrixA.values[4] * matrixB.values[3]) + (matrixA.values[5] * matrixB.values[7]) + (matrixA.values[6] * matrixB.values[11]) + (matrixA.values[7] * matrixB.values[15]) 
      }, 
      new float[] { 
        (matrixA.values[8] * matrixB.values[0]) + (matrixA.values[9] * matrixB.values[4]) + (matrixA.values[10] * matrixB.values[8]) + (matrixA.values[11] * matrixB.values[12]), 
        (matrixA.values[8] * matrixB.values[1]) + (matrixA.values[9] * matrixB.values[5]) + (matrixA.values[10] * matrixB.values[9]) + (matrixA.values[11] * matrixB.values[13]), 
        (matrixA.values[8] * matrixB.values[2]) + (matrixA.values[9] * matrixB.values[6]) + (matrixA.values[10] * matrixB.values[10]) + (matrixA.values[11] * matrixB.values[14]), 
        (matrixA.values[8] * matrixB.values[3]) + (matrixA.values[9] * matrixB.values[7]) + (matrixA.values[10] * matrixB.values[11]) + (matrixA.values[11] * matrixB.values[15]) 
      }, 
      new float[] { 
        (matrixA.values[12] * matrixB.values[0]) + (matrixA.values[13] * matrixB.values[4]) + (matrixA.values[14] * matrixB.values[8]) + (matrixA.values[15] * matrixB.values[12]), 
        (matrixA.values[12] * matrixB.values[1]) + (matrixA.values[13] * matrixB.values[5]) + (matrixA.values[14] * matrixB.values[9]) + (matrixA.values[15] * matrixB.values[13]), 
        (matrixA.values[12] * matrixB.values[2]) + (matrixA.values[13] * matrixB.values[6]) + (matrixA.values[14] * matrixB.values[10]) + (matrixA.values[15] * matrixB.values[14]), 
        (matrixA.values[12] * matrixB.values[3]) + (matrixA.values[13] * matrixB.values[7]) + (matrixA.values[14] * matrixB.values[11]) + (matrixA.values[15] * matrixB.values[15]) 
      } 
    }); 

    return matrix; 
}