[OpenGL] Grundlegendes zum Koordinatensystem

[Condottiero]

Hallo Zusammen,

OpenGL verwendet ja ein rechtshändiges Koordinatensystem, bei dem die (positiven) Achsen X, Y und Z nach rechts, oben und zum Betrachter hin verlaufen. Wieso muss ich bei glOrtho() dann als zNear-Value einen negativen Wert eingeben?

Beispiel:
Ich erzeuge mir eine Pyramide im Zentrum des Koordinatenkreuzes. Die Eckpunkte bewegen sich alle im Koordinatenbereich von x = -2.5 bis 2.5, y = -2.5 bis 2.5 und z = -2.5 bis 2.5. Möchte ich die Pyramide nun auch sichtbar haben, muss ich einen orthogonalen Raum mit mind. diesen Abmessungen erzeugen (mindestens, damit die Pyramide von einer Seite aus vollständig sichtbar ist).

Wie oben schon gefragt: wieso muss der Wert für zNear in dem Fall negativ sein, wenn doch laut Koordinatensystem die positive z-Achse auf den Betrachter zukommt.

Oder bin ich hier völlig auf dem Holzweg und die positive z-Achse geht nach "hinten" weg?

Viele Grüße,
Chris

[kristof]

Die Kamera steht bei OpenGL immer genau im Nullpunkt und sie guckt in die negative z-Richtung. Das heisst, dass die Kamera nur den negativen Teil der z-Achse sieht. Über zNear gibst du ja die Position der near clipping plane an. Soweit ich weiss muss die aber immer vor der Kamera angeordnet sein, also im negativen z-Bereich.
Erklärt das deine Frage?

Blödsinn.
http://www.opengl.org/sdk/docs/man/xhtml/glOrtho.xml
Das sollte auch dein Beispiel mit der Pyramide erklären. Deine Pyramide ist ja zum Teil hinter der Kamera. deshalb musst du in dem Fall eine negative Position angeben um die Pyramide trotzdem vollständig zu sehen.

Gruß,
Kristof

[Condottiero]

Hallo und erstmal danke für deine Antwort.

Okay, hab' deine korrigierte Antwort zu spät gesehen. :-D Ich glaube, jetzt ist es klar soweit, danke. ^^

Nur noch mal zur Sicherheit: Die z-Achse in Richtung des Betrachters (also zu mir vor dem Monitor) ist positiv, richtig?[/color]

In gewisserweise erklärt das meine Frage ein wenig.

Hier mal ein Beispielcode:

Code: Alles auswählen

	glClearColor(1.0, 1.0, 1.0, 1.0);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glOrtho(-6.0, 6.0, -6.0, 6.0, -6.0, 6.0);
	glEnable(GL_DEPTH_TEST);

	...

	GLfloat vec1[3] = {0.0, 2.5, 0.0};		// Festlegung der Vertices
	GLfloat	vec2[3] = {2.5, -2.5, 2.5};
	GLfloat	vec3[3] = {-2.5, -2.5, 2.5};
	GLfloat	vec4[3] = {-2.5, -2.5, -2.5};
	GLfloat	vec5[3] = {2.5, -2.5, -2.5};

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	//Pyramide
	glBegin(GL_TRIANGLES);		// Rendern der Seitenflächen
		glColor3f(1.0, 0.0, 1.0);
		glVertex3fv(vec1);
		glVertex3fv(vec2);
		glVertex3fv(vec3);
		glColor3f(1.0, 0.0, 0.0);
		glVertex3fv(vec1);
		glVertex3fv(vec3);
		glVertex3fv(vec4);
		glColor3f(0.0, 1.0, 0.0);
		glVertex3fv(vec1);
		glVertex3fv(vec4);
		glVertex3fv(vec5);
		glColor3f(0.0, 0.0, 1.0);
		glVertex3fv(vec1);
		glVertex3fv(vec5);
		glVertex3fv(vec2);
	glEnd();
	glBegin(GL_QUADS);	// Rendern der Grundfläche
		glColor3f(0.0, 0.3, 0.2);
		glVertex3fv(vec2);
		glVertex3fv(vec3);
		glVertex3fv(vec4);
		glVertex3fv(vec5);
	glEnd();

	glFlush();

Soo, im obigen Beispiel lege ich mir einen orthogonalen Raum von x = -6 bis +6, y = -6 bis +6 und z = -6 bis +6 an. Richtig?
Die Kanten der Pyramide verlaufen von auf den Koordinaten (x/z) (2.5/2.5) (-2.5/2.5) (-2.5/-2.5) (2.5/-2.5). y ist dauerhaft auf -2.5 und die Spitze der Pyramide liegt auf 0/2.5/0.

Starte ich nun das Programm wird mir die violette Frontseite der Pyramide angezeigt. Wie kan das aber sein, wenn die Kamera immer im Ursprung des Koordinatensystems liegt?

Es ist doch richtig, dass die z-Achse, die auf den Betrachter (also auf mich, vor dem Monitor sitzend) zukommt positiv ist, oder?

Grüße,
Chris

[kristof]

Nur noch mal zur Sicherheit: Die z-Achse in Richtung des Betrachters (also zu mir vor dem Monitor) ist positiv, richtig?

Genau. Du sitzt im positiven z-Bereich, der Bildschirm ist die xy-Ebene, und alles dahinter ist im negativen z-Bereich.

[suke]

Hi!

Ich habe schon einige Jahre nicht mehr mit OpenGL gearbeitet, doch einiges weiß ich noch. Also, verzeiht mir, wenn etwas nicht stimmt.
Die Vorstellung, dass die Kamera im Koordinatenursprung ist, wird nur für die Berechnung der Modelview-Matrix benötigt. Du veränderst mit glOrtho aber die Projection-Matrix, welche die Vertices in den Clip-Space überführt. Im Clip-Space wird alles angezeigt, was im Bereich [-1;1] ist. Du kannst auch den Clip-Space als einen Würfel vorstellen.
In deinem Beispiel ist die Modelview-Matrix eine Einheitsmatrix und verändert somit nichts. Rechne einmal die Matrix, die glOrtho liefert, händisch nach und berechne die neuen Koordinaten deiner Vertices. Du wirst merken, dass sie alle im Clip-Space sind und dass dein violettes Dreieck, welches durch die positiven Z-Koordinaten näher zum Bildschirm liegt, alle anderen überdeckt und am Bildschirm angezeigt wird.