SharpGL madness

Question

Hello,

I've ported 1-1 this code from C++/OpenGL to C# SharpGL:

float[] cameraAngle = { 0, 0, 0 };
        float[] cameraPosition = { 0, 0, 10 };
        float[] modelPosition = { 0, 0, 0 };
        float[] modelAngle = { 0, 0, 0 };

        float[] matrixView = new float[16];
        float[] matrixModel = new float[16];
        float[] matrixModelView = new float[16];

        // clear buffer
        gl.ClearColor(0.1f, 0.1f, 0.1f, 1);
        gl.Clear(OpenGL.COLOR_BUFFER_BIT | OpenGL.DEPTH_BUFFER_BIT | OpenGL.STENCIL_BUFFER_BIT);

        // initialze ModelView matrix
        gl.PushMatrix();
        gl.LoadIdentity();

        // ModelView matrix is product of viewing matrix and modeling matrix
        // ModelView_M = View_M * Model_M
        // First, transform the camera (viewing matrix) from world space to eye space
        // Notice all values are negated, because we move the whole scene with the
        // inverse of camera transform
        gl.Rotate(-cameraAngle[0], 1, 0, 0); // pitch
        gl.Rotate(-cameraAngle[1], 0, 1, 0); // heading
        gl.Rotate(-cameraAngle[2], 0, 0, 1); // roll
        gl.Translate(-cameraPosition[0], -cameraPosition[1], -cameraPosition[2]);

        // we have set viewing matrix upto this point. (Matrix from world space to eye space)
        // save the view matrix only
        gl.GetFloat(OpenGL.MODELVIEW_MATRIX, matrixView); // save viewing matrix
        //=========================================================================
        // always Draw the grid at the origin (before any modeling transform)
        //DrawGrid(10, 1);

        // In order to get the modeling matrix only, reset OpenGL.MODELVIEW matrix
        gl.LoadIdentity();

        // transform the object
        // From now, all transform will be for modeling matrix only. (transform from object space to world space)
        gl.Translate(modelPosition[0], modelPosition[1], modelPosition[2]);
        gl.Rotate(modelAngle[0], 1, 0, 0);
        gl.Rotate(modelAngle[1], 0, 1, 0);
        gl.Rotate(modelAngle[2], 0, 0, 1);

        // save modeling matrix
        gl.GetFloat(OpenGL.MODELVIEW_MATRIX, matrixModel);
        //=========================================================================
        // re-strore OpenGL.MODELVIEW matrix by multiplying matrixView and matrixModel before drawing the object
        // ModelView_M = View_M * Model_M
        gl.LoadMatrixf(matrixView);              // Mmv = Mv
        gl.MultMatrixf(matrixModel);             // Mmv *= Mm

        // save ModelView matrix
        gl.GetFloat(OpenGL.MODELVIEW_MATRIX, matrixModelView);
        //=========================================================================

        // Draw a teapot after ModelView transform
        // v' = Mmv * v
        //DrawAxis(4);
        //DrawTeapot();

        gl.PopMatrix();

It doesn't look like the ModelView matrix gets multiplied, the result is the Identity Matrix!

What could be wrong??

Thanks

Answer 1

wrong glMatrixMode?