Hallo.
Ich habe ein recht einfaches problem, nur leider komme ich auf keine gültige Lösung:
Ich habe schon ein wenig programmiert und habe nun folgendes Problem:
ich möchte (zunächst nur einen, es werden später mehr) einen GL_POINT in einer bestimmten Größe zeichnen.
Ich habe eine funktionierende Kamera deren Werte von Position, Look und V, clipNear und clipFar sowie die vertikale und horizontale Auflösung ich abfragen kann.
Soweit so gut.
Ich möchte nun einen GL_POINT zeichnen, der exakt so groß ist wie eine Seite eines Würfels den ich mit GL_LINE_STRIPs zeichne.
wichtig ist dabei dass der GL_POINT seine größe gleichmäßig mit dem würfel verändert wenn ich die kamera bewege.
Die Position des GL_POINTs habe ich in das Zentrum der Seite des Würfels gesetzt und die Größe des Points wie folgt berechnet:

größe= Größe des Punktes im Object-Space (also = seitenlänge des Würfels)
größe /= (Länge des Vektors von der Position des Punktes zur Position der Kamera)
größe /= clipNear
größe *= Max(Res_X, Res_Y);

das liefert schon ganz gute ergebnisse, aber ist leider falsch ;-)
ich weiss nicht so ganz ob ich mich verständlich ausgedrückt habe. Ich möchte in einer Szene also GL_POINTs zusammen mit Dreiecken und Lines verwenden und muss also für die GL_POINTS die GL_POINTSIZE so setzen dass bei animationen die Größe entsprechend mit der Umgebung skaliert.

(mir ist natürlich bewusst dass sich die GL_POINTS immer zum betrachter drehen und daher das Beispiel mit dem Würfel nicht gut ist, aber darum geht es mir nicht)

glPointSize kann nicht fließend skalieren, sondern nimmt den Wert, der deiner Eingabe am nächsten liegt.

Viele Informationen zu diesem Befehl findest du im DGL-Wiki: http://wiki.delphigl.com/index.php/GlPointSize

_________________
Blog: kevin-fleischer.de und fbaingermany.com

Danke für die schnelle Antwort.
Ich weiss auch dass glPointSize nur ganze Zahlen annehmen kann und einen gegebenen Wertebereicht hat, aber innerhalb dieses Wertebereiches und gerundet auf ganze Zahlen muss ich doch trotzdem die glPointSize irgendwie selber berechnen um den Punkt bei einer Bewegung durch die Szene an die Größe der Umgebung anzupassen. Und da weiss ich leider nicht so genau wie das geht.

Ich weiß auch nicht ob dich dich richtig verstanden habe, aber warum nimmst du nicht ein Quad, was an der Stelle gezeichnet wird und durch Billboarding zum Betrachter zeigt? Dann hast du den gleichen Effekt wie mit GL_POINTS plus dass die Fläche mit der Tiefe immer kleiner wird, was ja bei Punkten nicht der Fall ist.

such mal nach glpointparamter. wenn ich das jetzt richtig im kopf habe kann man damit die punkte nach der entfernung skalieren lassen.

Mist....gerade die Function ist net im Wiki....gleich mal gucken, obs irgendwo ne vernünftige Beschreibung gibt. Die einzigste die ich gefunden habe is von OpenGL ES. (http://www.khronos.org/opengles/documen ... meter.html)

_________________
Blog: kevin-fleischer.de und fbaingermany.com

Die Seite hatte ich heut auch schonmal vor der Nase. Ich komm aber mit dieser Form der Befehlsbeschreibung weit weniger gut zurecht, als mit der althergebrachten. Da sieht man wenigstens gleich was Phase ist.

_________________
Blog: kevin-fleischer.de und fbaingermany.com

Ja, das wäre eine Möglichkeit, allerdings würde ich das gerne Vermeiden, da (wenn ich das richtig verstehe) ein Quad durch 4 vertices definiert wird, was die Anzahl der zu übertragenden Vertices vervierfachen würde. Da ich mehrere Millionen solcher Punkte zeichnen und berechnen muss, könnte das zu langam werden.



Ehrlich gesagt verstehe ich die Beschreibung nicht so ganz. Es ist allerdings auch nicht so ganz das was ich suche, da ich in meinem Programm die Größe der (projizierten) Punkte kennen muss, um vernünftige Auswahkriterien zu haben. Zur Not könnte ich meine (fehlerhafte) Berechnung der Größe als Abschätzung zugrunde legen, und die Darstellung über den glPointParameter skalieren lassen, allrdings müsste ich den dazu erst verstehen und zum anderen wäre meine Berechnung innerhalb des Programmes immer noch fehlerhaft.

Vielen Dank für die guten Tipps, aber ich suche eigentlch eine Formel um die projizierte Größe eines GL_POINTs (oder eines anderen Primitivs) zu Berechnen.
Wenn ich weiss mein Quadrat-Objekt hat die Welt-Koordinaten (0,0,0) und die Größe 5, meine Kamera steht bei (-6,0,0) und guckt nach (0,0,0) mit einer Auflösung von 1024x1024, wie groß müsste die glPointSize sein um den GL_POINT deckungsgleich mit einem GL_QUAD hinzubekommen (+-1Pixel natürlich). Das muss sich doch irgendwie berechnen lassen.

Ich habe das schon ein bisschen verfolgt und die Punkte genau so ausrechnen zu lassen wie ein Quad ist auf Grund der unterschiedlichen Basiswerte (Pixel, Weltkoordinaten) alles andere als leicht und üblich.

Zu dem sagst du etwas von mehrere Mio Punkte. Moderne Grafikkarten dürfte bei 1 Mio schon reichlich Probleme bekommen. (Multipliziert mal die Punktgröße) Ich denke mal nicht, dass du dir dann noch den Luxus leisten kannst um die Größe eines jeden Punktes individual berechnen zu können. Vor allem wenn man bedenkt, dass du solche Größenordnungen ausschließlich nur mit Displaylisten oder VBOs erreichen kannst. Und dann bräuchtest du für jede Punktgröße eine eigene Liste. Beim iterativem Renden dürftest du allerdings schon bei 50.000 Punkte an das Maximum der Hardware gelangen ohne auch nur eine Größe selber berechnet zu haben. Wenn du deine Ansicht auch noch drehen möchtest ist es ganz aus. Wie gesagt denke ich mal sehr stark, dass du um point_parameters nicht herum kommen wirst. Abegesehen davon denke ich mal, dass es dem Benutzer egal sein wird ob die Punkte sich Haar genau so wie Flächen verhalten. Also von der Tiefe. Ich denke auch mal, dass es 99% der Benutzern gar nicht auffallen wird.

Also ich würde mal behaupten, dass die größe der Punkte einfach Proportional zür entvernung zur Kamera abnimmt!
Diese Berechnung müsste doch "relativ" schnell gehen...
Oder verstehe ich jetzt etwas falsch?

_________________
Nothing, oh sweet nothing,
today we are doing nothing at all...
http://www.geo-progs.de

Ja, du hast natürlich recht, es geht nicht so einfach. Aber ich möchte zum Beispiel berechnen können: Die Bounding-Box um das (Teil-) Objekt A wird auf nur 3x3 Pixel abgebildet, also rendere ich anstelle der 50 Dreiecke die in der Bounding Box liegen einen GL_POINT der Größe 3. Wenn ich dann das für alle Bounding-Boxes mache und nachher Listen mit Punkten der Größe 1, 2, 3... 10 habe, möchte ich diese einfach Darstellen. Das klappt auch noch nicht so toll, aber das ist ein anderes Problem. Momentan beschäftigt mich eben "wie erkenne ich welche Bounding-Box (oder Bounding Sphere meinetwegen) welche GL_POINTSIZE zugeordnet bekommen kann". Mit den mehreren Mio Punkten, das scheint bis jetzt ganz gut zu klappen, ich kann ja während des renderings ein wenig geschickt Punkte die ich nicht brauche ignorieren, nur fürchte ich eben dass GL_QUADS zu langsam sein könnten.



Richtig, so sehe ich das auch. Leider weiss ich nicht genau wie.
Wie gesagt, mein erster Versuch, die Länge des Vektors vom Augpunkt zum Mittelpunkt des Objektes zu nehmen (siehe oben), ging zwar schon in die richtige Richtung (d.h. der Punkt wird kleiner wenn ich weiter weg bin), schlug aber leider fehl (er wird schneller kleiner und größer als der Würfel der die Bounding Box repräsentieren soll).

Abstand=Wurzel(VektorPunktProdukt(KameraPosition-PunktPosition)))

oder halt, wenn v=Kamera Position-PunktPosition ist wäre das:

Abstand=sqrt(sqr(vx)+sqr(vy)+sqr(vz))

Die größw des Punktes wäre dann:

Größe=Konstante*1/Abstand

Die Konstante kannste dann durch Rumprobieren ermitteln.

Bei ner Ebenen Projektion (Ich denke openGL macht sowas) müsste das stimmen

Bei ner Spheren Projektion natürlich nicht genau...

_________________
Nothing, oh sweet nothing,
today we are doing nothing at all...
http://www.geo-progs.de

Ich denke mal, dass der Parameter FieldOfView (fovy) bei gluPerspective auch nicht ganz unwichtig ist. Und je nach dessen Wert erscheint ein 3x3 Quad alleine im Stillstand schon kleiner oder größer. Wenn man den fovy kleiner macht und sich die Breite eines Objektes in der Tiefe anschaut wird man feststellen, dass es breiter ist als wie wenn fovy größer ist. Sozusagen die Fehlende Perspektive bei der Ansicht. Diese müsstest du natürlich auch mit berücksichtigen.

Also denke ich mal, dass man sich die Projektionsmatrix schnappen muss und mit dieser arbeiten muss. Allerdings wie das zu machen ist weiß ich nicht. Das übersteigt meinen Horizont. Es kann auch sein, dass ich das gerade vollkommen falsch sehe.


Noch etwas am Rande. Nicht alle Grafikkarten unterstützen bei den Punkten unterschiedliche Größen. Es kann also sein, dass du irgendwann mal ne implementation mit Min = 1 und Max = 1 erwischst. Dann musst du wohl oder übel auf Quads zurückgreifen. Ob du dann willst oder nicht. Das solltest du bei deiner Programmierung berücksichtigen.

Ich würde Quads benutzen, weil die leichter zu kontrollieren sind. Man zeichnet es einfach an die gewünschte Position, während man beim Punkt noch die verschiedenen Parameter für Größe und Abnahme der Größe usw... alles einstellen muß.