Matrixmultiplication - Own Implementation of glTranslate? Wrong Matrix - opengl-es

Question

Assuming I have the following Projection Matrix (its computed using gluPerspective(40, 1.0, 0.2, 200.0); on the identity matrix):
2.75, 0.00, 0.00, 0.00,
0.00, 2.75, 0.00, 0.00,
0.00, 0.00, -1.00, -1.00,
-0.00, -0.00, -0.40, -0.00
and want to do an glTranslatef(0.0, 0.0, -10.0); command on this matrix. With openGL ES 1.1 function I recieve (that seems correct in my opinion):
2.75, 0.00, 0.00, 0.00,
0.00, 2.75, 0.00, 0.00,
0.00, 0.00, -1.00, -1.00,
0.00, 0.00, 9.62, 10.00
But if I use my own implementation (openGL ES 2.0), I got some strange behavior:
2.75, 0.00, 0.00, 0.00,
0.00, 2.75, 0.00, 0.00,
0.00, 0.00, 9.00, -1.00,
0.00, 0.00, -0.40, 0.00
My code is quite similiar to Apples openGLES1/2 Example and this site http://iphonedevelopment.blogspot.com/2009/06/opengl-es-from-ground-up-part-7_04.html:
void Matrix::translate(GLfloat xTranslate, GLfloat yTranslate, GLfloat zTranslate){
GLfloat matrix[16];
matrix[0] = matrix[5] = matrix[10] = matrix[15] = 1.0;
matrix[1] = matrix[2] = matrix[3] = matrix[4] = 0.0;
matrix[6] = matrix[7] = matrix[8] = matrix[9] = 0.0;
matrix[11] = 0.0;
matrix[12] = xTranslate;
matrix[13] = yTranslate;
matrix[14] = zTranslate;
multiMatrix(matrix);
}
void Matrix::multiMatrix(const GLfloat* a){
GLfloat* matrix;
GLfloat b[16];
matrix = currentMatrix(); //gets the ProjectionMatrix as GLfloat*
copyMatrix(matrix, b);
matrix[0] = a[0] * b[0] + a[4] * b[1] + a[8] * b[2] + a[12] * b[3];
matrix[1] = a[1] * b[0] + a[5] * b[1] + a[9] * b[2] + a[13] * b[3];
matrix[2] = a[2] * b[0] + a[6] * b[1] + a[10] * b[2] + a[14] * b[3];
matrix[3] = a[3] * b[0] + a[7] * b[1] + a[11] * b[2] + a[15] * b[3];
matrix[4] = a[0] * b[4] + a[4] * b[5] + a[8] * b[6] + a[12] * b[7];
matrix[5] = a[1] * b[4] + a[5] * b[5] + a[9] * b[6] + a[13] * b[7];
matrix[6] = a[2] * b[4] + a[6] * b[5] + a[10] * b[6] + a[14] * b[7];
matrix[7] = a[3] * b[4] + a[7] * b[5] + a[11] * b[6] + a[15] * b[7];
matrix[8] = a[0] * b[8] + a[4] * b[9] + a[8] * b[10] + a[12] * b[11];
matrix[9] = a[1] * b[8] + a[5] * b[9] + a[9] * b[10] + a[13] * b[11];
matrix[10] = a[2] * b[8] + a[6] * b[9] + a[10] * b[10] + a[14] * b[11];
matrix[11] = a[3] * b[8] + a[7] * b[9] + a[11] * b[10] + a[15] * b[11];
matrix[12] = a[0] * b[12] + a[4] * b[13] + a[8] * b[14] + a[12] * b[15];
matrix[13] = a[1] * b[12] + a[5] * b[13] + a[9] * b[14] + a[13] * b[15];
matrix[14] = a[2] * b[12] + a[6] * b[13] + a[10] * b[14] + a[14] * b[15];
matrix[15] = a[3] * b[12] + a[7] * b[13] + a[11] * b[14] + a[15] * b[15];
}
void Matrix::copyMatrix(const GLfloat* source, GLfloat* destination){
for(int i=0; i<16; i++){
destination[i] = source[i];
}
}
Im debugging this for 2 days now and have now idea what Im missing... Any ideas?

Answer 1

I always refer to this excellent implementation. The code is easy to follow and it just works.
Their translate method is pasted here:
translate: function (tx, ty, tz) {
this.elements[3*4+0] += this.elements[0*4+0] * tx + this.elements[1*4+0] * ty + this.elements[2*4+0] * tz;
this.elements[3*4+1] += this.elements[0*4+1] * tx + this.elements[1*4+1] * ty + this.elements[2*4+1] * tz;
this.elements[3*4+2] += this.elements[0*4+2] * tx + this.elements[1*4+2] * ty + this.elements[2*4+2] * tz;
this.elements[3*4+3] += this.elements[0*4+3] * tx + this.elements[1*4+3] * ty + this.elements[2*4+3] * tz;
return this;
},

Answer 2

It's a bit hard to tell from your code, but are you intending to use row-order or column-order for your matrices? Row-order would be more common, but you are creating a column-order translation matrix. A translation matrix has the translation 3-vector running down the right-most column from the top-right corner, not along the bottom row.
In a row-ordered matrix, the rows are contiguous blocks so the first four numbers are the top row. In a column-ordered matrix, the columns are contiguous blocks so the first four numbers are the first column.
If I'm reading your code correctly, then it looks like your multiMatrix function is right-multiplying the parameter matrix against the standing class matrix, using row-order. That would be correct for translate if the matrix was row-ordered, so you need to transpose the translation matrix you are creating.