[/if (RenderSingleton::Instance()._GenerateShadowMap!=true)
	{
//first render pass
		const Vector3f _LightPosition(501.0f, 501.0f, 510.0f );
		Vector3d _LightLookAt(0.0, 0.0, 0.0 );
		
		glClear(GL_DEPTH);
		

	    //Shading states
	    glShadeModel(GL_SMOOTH);
	    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);

	    //Depth states
	    glClearDepth(1.0f);
	    //zeichnet alles was gleich oder niedriger ist
	    glDepthFunc(GL_LEQUAL);
		//nur tiefentest wird aktiviert

		glEnable(GL_DEPTH_TEST);

	    glEnable(GL_CULL_FACE);

		const Vector4f Color(0.2f,0.2f,0.2f,0.2f);
		//Lichtquelle
		glLightfv(GL_LIGHT1,GL_POSITION,_LightPosition);
		glLightfv(GL_LIGHT1, GL_AMBIENT, Color);
	    glLightfv(GL_LIGHT1, GL_DIFFUSE, Color);

		glEnable(GL_LIGHTING);
		glEnable(GL_LIGHT1);
		glEnable(GL_LIGHT0);
		glEnable(GL_COLOR_MATERIAL);

		//Textur initialisieren
		glGenTextures(1, &shadowMap);
		glBindTexture(GL_TEXTURE_2D,shadowMap);

		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);

		
		
		Position3d eye = Camera()->Eye();
		Position3d eyeLookAt = Camera()->Target();
		UnitVector3d eyeTopVec = Camera()->UpDirection();

		Vector3d _CameraPosition(eye[0],eye[1],eye[2]);
		Vector3d _CameraLookAt(eyeLookAt[0], eyeLookAt[1], eyeLookAt[2]);
		Vector3d _CameraTopVec(eyeTopVec[0], eyeTopVec[1], eyeTopVec[2]);


		GLViewPort view = Camera()->ViewPort();

		Vector4f _View(view[0],view[1],view[2],view[3]);

		if (view[3] != 0){

		glPushMatrix();
			glLoadIdentity();
			gluPerspective(45.0,(view[2]/view[3]),500.0,1050.0 );
			glGetDoublev(GL_MODELVIEW_MATRIX,lightProjectionMatrix);
			glPopMatrix();
		}
		else 
		{
			view[3]=1;
		glPushMatrix();
			glLoadIdentity();
			gluPerspective(45.0,(view[2]/view[3]),500.0,1050.0 );
			glGetDoublev(GL_MODELVIEW_MATRIX,lightProjectionMatrix);
			glPopMatrix();
		}

		glPushMatrix();
			glLoadIdentity();
			gluLookAt(_LightPosition[0], _LightPosition[1], _LightPosition[2],
					_LightLookAt[0], _LightLookAt[1], _LightLookAt[2],
					0.0, 0.0, 1.0);
			glGetDoublev(GL_MODELVIEW_MATRIX, lightViewMatrix);
			glPopMatrix();
		
		glPushMatrix();
			glLoadIdentity();
			gluLookAt(_CameraPosition[0],_CameraPosition[1],_CameraPosition[2],
						_CameraLookAt[0], _CameraLookAt[1], _CameraLookAt[2],
						_CameraTopVec[0], _CameraTopVec[1], _CameraTopVec[2]);
			glGetDoublev(GL_MODELVIEW_MATRIX, cameraViewMatrix);
			glPopMatrix();	
		 
		glPushMatrix();
			glLoadIdentity();
			gluPerspective(45.0f, view[2]/view[3], 1.0f, 500.0f);
			glGetDoublev(GL_MODELVIEW_MATRIX, cameraProjectionMatrix);
			glPopMatrix();


		
			//ShaderExtensions::glUseProgramObjectARB(0);
			//glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
		
			glLoadIdentity();

			glViewport(0 ,0 ,view[2] ,view[3]);
			
			glMatrixMode(GL_PROJECTION);
			glPushMatrix();

			//Perspektive des Lichts
			
			glLoadMatrixd(lightProjectionMatrix);
			//glPushMatrix();
			glMatrixMode(GL_MODELVIEW);
			glLoadMatrixd(lightViewMatrix);
		
			glColorMask(0, 0, 0, 0);

			glPolygonOffset(1.1,4.0);
			glEnable(GL_POLYGON_OFFSET_FILL);
			glDisable(GL_LIGHTING);	

			//rendern
			_Root->Render(mode);

			//vom z-Buffer in textur kopieren
			glBindTexture(GL_TEXTURE_2D, shadowMap);
			glCopyTexImage2D(GL_TEXTURE_2D,0,GL_DEPTH_COMPONENT,0,0,view[2],view[3],0);

			
			glColorMask(1,1,1,1);
			//offsetting deaktivieren
			glDisable(GL_POLYGON_OFFSET_FILL);
			glDisable(GL_LIGHT1);

			//Model/ProjectionView Matrix zurücksetzen
			glMatrixMode(GL_PROJECTION);
			glPopMatrix();
			glMatrixMode(GL_MODELVIEW);
			glPopMatrix();

			glLoadIdentity();
			RenderSingleton::Instance()._GenerateShadowMap = true;]
}
else

	{//second render pass

	 const double mBias[] = {0.5, 0.0, 0.0, 0.0, 
						   0.0, 0.5, 0.0, 0.0,
						   0.0, 0.0, 0.5, 0.0,
						   0.5, 0.5, 0.5, 1.0};
        static Matrix4x4d biasMatrix(mBias);
       
	    Matrix4x4d textureMatrix=biasMatrix*lightProjectionMatrix*lightViewMatrix;

	    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
	    glTexGenfv(GL_S, GL_EYE_PLANE, Vector4f(textureMatrix[0], textureMatrix[4], textureMatrix[8], textureMatrix[12])/*textureMatrix.GetRow(0)*/);
	    glEnable(GL_TEXTURE_GEN_S);

	    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
	    glTexGenfv(GL_T, GL_EYE_PLANE, Vector4f(textureMatrix[1], textureMatrix[5], textureMatrix[9], textureMatrix[13])/*textureMatrix.GetRow(1)*/);
	    glEnable(GL_TEXTURE_GEN_T);

	    glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
	    glTexGenfv(GL_R, GL_EYE_PLANE, Vector4f(textureMatrix[2], textureMatrix[6], textureMatrix[10], textureMatrix[14])/*textureMatrix.GetRow(2)*/);
	    glEnable(GL_TEXTURE_GEN_R);

	    glTexGeni(GL_Q, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
	    glTexGenfv(GL_Q, GL_EYE_PLANE, Vector4f(textureMatrix[3], textureMatrix[7], textureMatrix[11], textureMatrix[15])/*textureMatrix.GetRow(3)*/);
	    glEnable(GL_TEXTURE_GEN_Q);

		glBindTexture(GL_TEXTURE_2D, shadowMap);
	    glEnable(GL_TEXTURE_2D);

	    //Enable shadow comparison
	    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE_ARB);

	    //Shadow comparison should be true (ie not in shadow) if r<=texture
	    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL);

	    //Shadow comparison should generate an INTENSITY result
	    glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE_ARB, GL_INTENSITY);
	
		 glAlphaFunc(GL_GEQUAL, 0.99f);
	    glEnable(GL_ALPHA_TEST);
		_Root->Render(mode);

		glDisable(GL_TEXTURE_2D);
		glDisable(GL_ALPHA_TEST);
	    glDisable(GL_TEXTURE_GEN_S);
	    glDisable(GL_TEXTURE_GEN_T);
	    glDisable(GL_TEXTURE_GEN_R);
	    glDisable(GL_TEXTURE_GEN_Q);
	    glDisable(GL_LIGHTING);


	

        //reset matrices
	    glMatrixMode(GL_PROJECTION);
	    glPopMatrix();
	    glMatrixMode(GL_MODELVIEW);
	    glPopMatrix();

_Root->Render(mode);

}]