OpenGL - Manueller Tiefentest - Abstand zur Kamera bestimmen

xindon

Hallo,

im Rahmen meiner Weltraumsimulation bin ich auf Ungenauigkeitsprobleme mit dem (32bit) Depthbuffer bestoßen, deswegen muss ich den Tiefentest nun manuell durchführen.

Gibt's denn da irgendwelche Hilfsfunktionen von GLU o.ä., mit denen ich die Position der Kamera / Abstände etc. bestimmen kann?

Vielen Dank,
Tim

rapso

wie willst du selbst die pixeltiefen pruefen? dann musst du ja alles selber zeichenen

zur bestimmung der tiefe von punkten brauchst du doch nichts ausser matrizen, den punkten und mathewissen... das sollte doch alles vorhanden sein?

TomasRiker

Tiefentest manuell? Der Tiefentest wird doch für jeden gezeichneten Pixel ausgeführt. Oder meinst du mit "manuell", dass du das in einem Shader machen willst? (Dann könntest du aber natürlich kein GLU verwenden)

Vielleicht hast du auch nur die Near- und Far-Clipping-Plane schlecht gesetzt. Vor allem die Near-Plane sollte so weit wie es geht nach hinten, da sonst ein Großteil der Genauigkeit für sehr kurze Abstände draufgeht.

xindon

Ok, ich hab mich glaub ich blöd ausgedrückt

Mit manuellem Tiefentest meine ich, dass ich meine 10 Planeten selbst von hinten nach vorne zeichne.
Ist im Grunde ja auch kein Problem, ich muss einfach nur wissen, wo sich die Kamera im Weltkoordinatensystem befindet, was ich jetzt auf den ersten Blick nach ein paar Translationen und Rotationen nicht einfach fand.

TomasRiker

Du musst doch selbst wissen, wo die Kamera ist - schließlich platzierst du sie doch irgendwo.

xindon

Also es ist so, meine Kamera ist immer auf einen bestimmen ausgewählten Planet fixiert. Man kann die Entfernung ("Zoom") verändern und eben nach oben/unten und rechts/links rotieren um den ausgewählten Planet.

Die Sonne hat immer die Koordinaten 0|0|0, die anderen Planeten entsprechend darum.

Mein Problem ist jetzt einfach, dass ich nicht weiß, wie ich die Entfernung von der Kamera zu den Planeten berechnen soll...

Vielen Dank!

glLoadIdentity();

   // Camera
   glTranslated(0.0, 0.0, -this->camera.distance);
   glRotated(-this->camera.verticalAngle, 1.0, 0.0, 0.0);
   glRotated(-this->camera.horizontalAngle, 0.0, 0.0, 1.0);
   glTranslated(-selectedPlanet->position.x, -selectedPlanet->position.y, -selectedPlanet->position.z);

   // Sun
   glCallList(this->sun.displayList);

   // Other planets
   for (unsigned int i = 0; i < this->sun.children.size(); i++) {
      Planet *planet = &this->sun.children.at(i);

      glTranslated(planet->position.x, planet->position.y, planet->position.z);
      glCallList(planet->displayList);
      glTranslated(-planet->position.x, -planet->position.y, -planet->position.z);
   }

TGGC

xindon schrieb:

Mein Problem ist jetzt einfach, dass ich nicht weiß, wie ich die Entfernung von der Kamera zu den Planeten berechnen soll...

Guckst du Mathebuch, Satz des Pythagoras. f'`8k

Autocogito

Gruß, TGGC (making great games since 1992)

xindon

Joaa, den werde ich wohl dafür brauchen.

Ich wollte doch einfach nur wissen, obs schon eine gute Möglichkeit gibt, die Kameraposition im Weltkoordinatensystem nach einer Reihe von Transformationen zu bestimmen..

Vielleicht hilft dir der folgende Link etwas weiter:

http://www.fl-tw.com/InfinityForums/viewtopic.php?t=73

Eventuell auch:

http://www.gamasutra.com/features/20020712/oneil_01.htm

Krux

Ich hätte die sache etwas anders angegangen, in glu gibt es

gluLookAt(		// Set camera position and orientation
posx,posy,posz,	// Camera position (x,y,z)
0.0, 0.0, 0.0,	// View point (x,y,z)
0.0, 0.0, 1.0	// Up-vector (x,y,z)
);

das Benutze ich immer, dann weß ich genau, wo meine Kamera ist. Dann vor jeder Matrixmanipulation glPushMatrix(); und hinterger wieder popmatrix();. Monde werden dann "rekursiv" erstellt. Dass würde allerdings das trcking mit gluLookAt erschweren. Aber man kann positionen von Planeten ja auch duch das addieren von zwei parametrischen kreisfunktionen bestimmen, also sowas wie

x(t)=sin(t)*5+sin(t*5)
y(t)=cos(t)*5+cos(t*5)

Mit diesen vorraussetzungen kann man natürlich recht simpel alle abstände Berechnen.

xindon

Ich kenne gluLookAt und hatte das auch vorher drin. Aber mit den einzelnen glTranslate/glRotate Befehlen hab ichs einfacher mit der Kamera.

Mir kommt grad eine Idee. Ich könnte doch einfach den 0|0|0 Vektor mit der Modelviewmatrix multiplizieren und habe dann die Position der Kamera im Koordinatensystem, oder ?