Rotation Transformation implementation for OpenGL with 4x4 Matrix - c++

Question

So I am learning OpenGL and I'm try to project an image:
To be like
However my implentation is resulting in:
The original tutorial is using GLM mathematics library but I wanted to try and implement it myself.
Matrix44& translate(float xi, float y, float z)
{
x[0][3] = xi;
x[1][3] = y;
x[2][3] = z;
return *this;
}
Matrix44& rotateX(float angle)
{
assert(angle >= 0.0f && angle <= 360.0f);
if (angle == 0.0f || angle == 360.f)
return *this;
x[1][1] = cos(angle * RAD);
x[1][2] = sin(angle * RAD);
x[2][1] = -sin(angle * RAD);
x[2][2] = x[1][1];
return *this;
}
Matrix44& rotateY(float angle)
{
assert(angle >= 0.0f && angle <= 360.0f);
if (angle == 0.0f || angle == 360.f)
return *this;
x[0][0] = cos(angle * RAD);
x[0][2] = -sin(angle * RAD);
x[2][0] = sin(angle * RAD);
x[2][2] = x[0][0];
return *this;
}
Matrix44& rotateZ(float angle)
{
assert(angle >= 0.0f && angle <= 360.0f);
if (angle == 0.0f || angle == 360.f)
return *this;
x[0][0] = cos(angle * RAD);
x[0][1] = -sin(angle * RAD);
x[1][0] = sin(angle * RAD);
x[1][1] = x[0][0];
return *this;
}
x[][] is the 4x4 matrix. By default it is set to be the identity matrix. And in main:
Matrix44f model{};
Matrix44f view{};
model.rotateY(180).rotateX(90);
view.translate(0.0f, 0.0f, -3.0f);
To get my image but with the GLM version of:
glm::mat4 model;
glm::mat4 view;
model = glm::rotate( model, ( GLfloat)glfwGetTime( ) * 1.0f, glm::vec3( 0.5f, 1.0f, 0.0f ) );
view = glm::translate( view, glm::vec3( 0.0f, 0.0f, -3.0f ) );
I then looked at the GLM implementation: GLM Maths Github
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> rotate
(
detail::tmat4x4<T, P> const & m,
T const & angle,
detail::tvec3<T, P> const & v
)
{
T const a = angle;
T const c = cos(a);
T const s = sin(a);
detail::tvec3<T, P> axis(normalize(v));
detail::tvec3<T, P> temp((T(1) - c) * axis);
detail::tmat4x4<T, P> Rotate(detail::tmat4x4<T, P>::_null);
Rotate[0][0] = c + temp[0] * axis[0];
Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1];
Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2];
Rotate[1][1] = c + temp[1] * axis[1];
Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0];
Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1];
Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0];
Rotate[2][2] = c + temp[2] * axis[2];
detail::tmat4x4<T, P> Result(detail::tmat4x4<T, P>::_null);
Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
Result[3] = m[3];
return Result;
}
I'm so confused as to what the Result[index] accesses in the 4 x 4 matrix? Does it represent column, the row or the diagonal position?!