SharpGL folie

Question

Je l'ai porté 1-1 ce code de C++/OpenGL à 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(); 

Il ne ressemble pas à la matrice MODELVIEW est multiplié, le résultat est la matrice identité!

Qu'est-ce qui pourrait se tromper?

Remerciements

Answer 1

incorrect glMatrixMode?