Also gibt diese Funtkion ein PixelFormat zurrück, was bei der Grafikkarte das AA aktiviert?

Ich weise das also dem Pixelformat zu mit SetPixelFormat.
Der zweite Parameter ist ja dann die (verlinkte) Funktion.
Doch was sind der erste und dritte? Und was kommt darein?

Die Zeile muss dann weg und die neuen drei an diese Stelle oder?

Entschuldige. Ich hatte deine Frage vollkommen verpennt. Die Intension hinter meinem Post war, dass du dir mal die Methode CreateRenderingContext genau anschaust. Also was dort innendrinne passiert. Aber dann mal kurz eine Erklärung dazu.

Als Erstes wird eine Struktur gefüllt. Und zwar wird in den TPixelFormatDescriptor geschrieben welche Eigenschaften dein Kontext besitzen soll. Anschließen wird mit ChoosePixelFormat ein Pixelformat ausgewählt. Dieses PixelFormat wird mit SetPixelFormat auf dein Formular zugewiesen. Als krönender Schluss wird mithilfe von wglCreateContext ein Kontext erstellt. Das alles passiert in CreateRenderingContext.

Die Methode von Lord Horazont ersetzt (erweitert) die Schritte zur Auswahl eines Pixelformates. Also das Befüllen von TPixelFormatDescriptor und das Auswählen mittels ChoosePixelFormat. Entsprechend müsste deine Änderung so aussehen, dass du CreateRenderingContext durch die Methode von Lorz Horazont ersetzt. Und anschließend SetPixelFormat und wglCreateContext aufrufst. Wie du das aufrufst schau dir bitte erst mal in CreateRenderingContext an. Den Befehl DescribePixelFormat kannst du dabei ignorieren. Der würde nur detailierte Informationen zu dem PixelFormat einholen. Das sind nur Infos für den Entwickler, wenn sie denn sinnvoll ausgewertet werden würden.

Hilf mir doch mal bitte ein bisschen bei dem Code...

Es muss also so aussehen:


Dann kommt Setpixelformat. Mit welchen Parametern???

Dann
Muss der Rendering Context nicht noch aktiviert werden?

Das da:
ist falsch, denn das PixelFormat und der RC sind NICHT das Gleiche.

Hier ein Beispiel von mir, das mal in Windows 2000 funkitoniert hat. In XP habe ich es noch nicht ausprobiert.


Hinweis: PixelFormatInfo.MultiSamplePixelFormat ist ein DatenTyp, der das vorher ermittelte Multisample-Pixelformat enthält.

Ob und wie das Ganze für eine Delphi-Form funktioniert, weiß ich nicht.

Warum ist das denn so kompliziert....

Also das ist der ursprüngliche Code aus dem Tutorial:


Wie muss ich den jetzt abändern, damit ich mit GetMultisamplePixelformat dann mein geglättetes Bild bekomme?

(Ich weis es ist nicht sinnvoll, fertigen Code zu posten, aber wir können doch mal eine Ausnahme machen.... Verstehen kann ichs danach ja immernoch)

Sollte übrigens erstmal unter Vista funktionieren und auf ein panel gerendert werden.

Schau mal da rein.
http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=46
Ganz am Ende findest du dann auch eine Delphi Umsetzung.

_________________
"Wer die Freiheit aufgibt um Sicherheit zu gewinnen, der wird am Ende beides verlieren"
Benjamin Franklin

Projekte: https://github.com/tak2004

... es ist zwar schon länger her, aber ich habe es bis jetzt noch nicht hinbekommen mit dem Antialiasing.
Es wurde ja auch eine einfachere, weniger elegante Methode vorgeschlagen.
Das ganze Zeugs einfach auf eine Textur rendern und die dann verkleinern.
Könnt ihr mir sagen wie ich den Quellcode dafür abändern muss?
Ich hab noch nicht wirklich viel mit OpenGL gemacht, und das vor Monaten...
In welchem Tutorial ist das beschrieben, was ich hierzu brauche?

Um mal eins klarzustellen: Antialiasing ist nicht gleich Antialiasing. Das mit dem Rendern in einer höheren Auflösung und anschließendem Runterskalieren heißt Supersampling. Es kostet sehr viel Leistung (wie man sich denken kann) und meiner Erfahrung nach sieht das Bild danach auch etwas unscharf aus.

Deutlich Resourcen-schonender ist das Multisampling, bei dem nur für die Polygon-Kanten zusätzliche Pixel gerendert werden. Dazu bieten die Treiber idR noch die Option, das nicht nur an den Kanten zu tun, sondern auch auf Flächen mit Alpha-Testing (und -Blending?). Nvidia nennt das "transparentes" Anitaliasing und ATI "adaptives" Antialiasing. Was Nvidia mit dem Coverage Sampling genau meint, habe ich wieder vergessen, jedenfalls wollen die damit bei mehr Leistung bessere Qualität rausschlagen.

In der c't gab's mal nen netten Artikel über die verschiedenen Formen von Antialiasing.

Edit: Oh, ich hab gar nicht gesehen, dass es eine zweite Seite gibt...

Gruß mrtrain

Das von dir angesprochene Verfahren findet vor allem in renderern mit Deferred Shading Einsatz (wie bei Stalker). Bei Forward-Renderen ist Hardware-AA einiges sinnvoller.

Edit: Ich habe die zweite Seite auch übersehen. Mein Post bezog sich auf den letzten Eintrag von Seite 1

_________________
http://audorra.sourceforge.net//http://andorra.sourceforge.net

Das mit diesen ganzen vielen Multisampling zeugs hat ja dann doch nicht funktioniert.

Es ist halt nur ein kleines Programm mit 54 einfachen polygonen, hohe framerate ist mir nicht so wichtig, ist auch nicht fullscree. ich möchte einfach, dass es ein bischen hübscher aussieht weil mir dieser stufen look nicht so gefällt.

ich suche also nach einer einfach zu programmierenden methode...

zu igel:
lies dir mal die vorposts durch...
hardware aa hab ich tausendmal probiert und es klappt eben doch nicht.

Wenn du dein Programm hübsch haben willst, würde ich nicht Supersampling benutzen. Wie ich schon schrieb, wird das Bild dabei (zumindest bei meiner Radeon) etwas unscharf, sodass ich lieber ganz ohne Antialiasing rendern würde. Das ist aber sicherlich Geschmackssache.

Ne simple Methode, die aber langsam ist, ist das Multipass-Verfahren.

Du renderst deine Szene n (n=4 oder 6) mal mit aktiviertem Blending und geringer Intensität (Alpha = 1/n).
Bei jedem Pass bewegst du deine "Kamera" um 1Pixel um den eigentlichen Standort herum.

Am Ende jedes Durchgangs löscht du den Tiefenpuffer und beginnst mit dem nächsten Durchgang

Das klingt recht aufwändig - und ist entsprechend langsam.

Das mit dem "Rotieren der Kamera um einen Punkt" könnte man vielleicht mit gluLookAt relativ easy hinbekommen.

PS: Das was ich hier geschrieben hab, ist quasi aus dem Kopf und ungetestet.

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

Ähm, das dürfte nicht den gewünschten Effekt erzielen. Was du da beschreibst ist eine Art Weichzeichner, allerdings einer der Artefakte erzeugt, weil eben nur der einfache Durchschnitt der Pixelfarben (1/n) berechnet wird. Würde man aber auch erst bei größerem n sehen. Der Grund für die Artefakte sind die mathematischen Eigenschaften der Durchschnittsfunktion bei einer Fouriertransformation. Will ich jetzt nicht darauf eingehen, weil hier unwichtig. Jedenfalls mit einer Gaußfunktion gibt es keine Artefakte, weil die Gaußfunktion nach der Fouriertransformation wieder eine Gaußfunktion ist. ABER...ein Weichzeichner war ja hier gar nicht gewünscht...

Für Antialiasing braucht es eine höhere Auflösung pro Pixel...Subpixel eben. Diese Subpixel werden dann zu einem Pixel zusammengefasst.

Das einfachste ist das erwähnte Supersampling, insbesondere weil es überall funktioniert...ich kenne das eigentlich unter dem Namen FSAA (FullSceneAntialiasing). Der Trick ist die Szene einfach mit 2x, 4x, 8x oder gar 16x größerer Auflösung in ein FBO zu rendern und dann runterzuskalieren. Wichtig: Es müssen 2er-Potenzen sein, sonst wird es unscharf. Bei 2x kommen z.B. genau 2x2 Pixel auf einen Pixel, daher bleibt das Bild scharf. Es sollte klar sein das der Aufwand quadratisch ist, also bei 16x müssen 256mal soviele Pixel gerendert werden. Hier kommt dann Deferred Shading zum Einsatz um z.B. Lichteffekte mit geringerer Auflösung zu berechnen. Licht wird normal mit 1x berechnet und dann mit dem 16x Bild kombiniert.

_________________
Yeah!

Also aus dem FBO Tutorial werde ich nicht so richtig schlau...

Wie wird denn das FBO später abgebildet, wenn alles darein gerendert wurde?
Und wo kann man die Größe eingeben?

Mittels FBO kannst du in eine Textur rendern. Diese Textur kann wie jede andere Textur verwendet werden, sobald du den FBO wieder abschaltest. Die Größe entspricht logischerweise der Größe der Textur.

_________________
Yeah!