OpenGL Sichtbarkeitsproblem

[gruto]

Hallo!

Ich habe angefangen mich mal mit opengl näher zu beschäftigen. Nun habe ich folgendes problem : ich versuche einen schatten eines teapots zu zeichnen jedoch wird mir immer entweder der teapot oder der schatten angezeigt jedoch nicht beides?
An was könnte das liegen ?

Sourcecode :

private static void init()
{
Gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
}
private static void display()
{

Gl.glClear (Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
Gl.glEnable(Gl.GL_DEPTH_TEST);
Gl.glNormal3f(1.0f,1.0f,1.0f);
Glut.glutSolidTeapot (2);
Gl.glPushMatrix();
Gl.glDisable(Gl.GL_DEPTH_TEST);
Gl.glColor3f(1.0f,1.0f,0.5f);
Gl.glMultMatrixd(setShadowMatrix(findplane(p0,p1,p2),lightPos));
Glut.glutSolidTeapot (2);
Gl.glPopMatrix(); //wenn hier kein popMatrix() gesetzt wird dann wird der schatten gezeichnet , jedoch nicht der teapot???
Gl.glEnable(Gl.GL_DEPTH_TEST);
Glut.glutSwapBuffers();
}
//setShadowMatrix
private static double[] setShadowMatrix(double[] plane_eq,double[] lightpos) {

// Find dot product between light position vector and ground plane normal.
double dot = plane_eq[0] * lightpos[0] +
plane_eq[1] * lightpos[1] +
plane_eq[2] * lightpos[2] +
plane_eq[3] * lightpos[3];

sm[0] = dot - lightpos[0] * plane_eq[0];
sm[4] = - lightpos[0] * plane_eq[1];
sm[8] = - lightpos[0] * plane_eq[2];
sm[12] = - lightpos[0] * plane_eq[3];

sm[1] = - lightpos[1] * plane_eq[0];
sm[5] = dot - lightpos[1] * plane_eq[1];
sm[9] = - lightpos[1] * plane_eq[2];
sm[13] = - lightpos[1] * plane_eq[3];

sm[2] = - lightpos[2] * plane_eq[0];
sm[6] = - lightpos[2] * plane_eq[1];
sm[10] = dot - lightpos[2] * plane_eq[2];
sm[14] = - lightpos[2] * plane_eq[3];

sm[3] = - lightpos[3] * plane_eq[0];
sm[7] = - lightpos[3] * plane_eq[1];
sm[11] = - lightpos[3] * plane_eq[2];
sm[15] = dot - lightpos[3] * plane_eq[3];

return sm;
}

// findplane
// Calculate A,B,C,D version of plane equation,
// given 3 non-colinear points in plane
private static double[] findplane(double[] p0,double[] p1,double[] p2)
{
double[] vec0 = new double[3];
double[] vec1 = new double[3];
plane_eq= new Double[4];

// Need 2 vectors to find cross product.
vec0[0] = p1[0] - p0[0];
vec0[1] = p1[1] - p0[1];
vec0[2] = p1[2] - p0[0];

vec1[0] = p2[0] - p0[0];
vec1[1] = p2[1] - p0[1];
vec1[2] = p2[2] - p0[2];

// find cross product to get A, B, and C of plane equation
plane_eq[0] = vec0[1] * vec1[2] - vec0[2] * vec1[1];
plane_eq[1] = vec0[2] * vec1[0] - vec0[0] * vec1[2];
plane_eq[2] = vec0[0] * vec1[1] - vec0[1] * vec1[0];

double normlen = Math.Sqrt(plane_eq[0]*plane_eq[0]
+ plane_eq[1]*plane_eq[1]
+ plane_eq[2]*plane_eq[2]);
if (normlen != 0)
{
plane_eq[0] /= normlen;
plane_eq[1] /= normlen;
plane_eq[2] /= normlen;
}
else
{
plane_eq[0] = 1;
plane_eq[1] = 0;
plane_eq[2] = 0;
}

plane_eq[3] = -(plane_eq[0] * p0[0]
+ plane_eq[1] * p0[1]
+ plane_eq[2] * p0[2]);

return plane_eq;
}


private static void reshape(int w,int h) {
Gl.glViewport(0,0,w,h);
Gl.glMatrixMode(Gl.GL_PROJECTION);
Gl.glLoadIdentity();
Glu.gluPerspective(60.0,(float)w/(float)h,100.0,10.0);
Gl.glMatrixMode(Gl.GL_MODELVIEW);
Gl.glLoadIdentity();

Glu.gluLookAt(0.0,10.0,10.0,0.0,0.0,0.0,0.0,10.0,0.0);
}

[STAThread]
public static void Main(string[] args)
{
Glut.glutInit();
Glut.glutInitDisplayMode (Glut.GLUT_DOUBLE | Glut.GLUT_RGB | Glut.GLUT_DEPTH);
Glut.glutInitWindowSize (500, 500);
Glut.glutInitWindowPosition (100, 100);
Glut.glutCreateWindow ("Test");
init ();
Glut.glutDisplayFunc(new Glut.DisplayCallback(display));
Glut.glutReshapeFunc(new Glut.ReshapeCallback(reshape));
Glut.glutMainLoop();
}

}

mfg gruto