JLI Spieleprogrammierung

[Fallen]

1. Einleitung

Unter ZBuffer Readback versteht man eine Technik die dazu benutzt wird Werte vom aktuellen ZBuffer zu ermitteln also zB die Tiefe.

Da ZBuffer auf selbst neueren Kartengenerationen nicht ausgelesen werden können (kein festgelegter Standard der ZBuffer Aufbewahrung/Kompression) ist der Entwickler der diese Daten braucht meist aufgeschmissen, eine Möglichkeit besteht darin die Szene und damit alle Objekte in eine separate Textur zu rendern mit einer Technik welche die Tiefe in die Textur legt (FP Texturen oder
nonFP Texturen).

Dies kostet allerdings ziemlich viel Leistung (Szene muss extra dafür gerendert werden) und läuft auch nicht bei jedem (Pixelshader Restriktionen,...). Noch dazu braucht man nicht immer die genauen Werte des ZBuffers. Daher gibt es eine Möglichkeit den ZWert der aktuellen Szene mit einem anderen Tiefen wert zu vergleichen. Mit diesem Vergleich und den durch die Technik resultierenden
Nebenprodukten lassen sich schon ziemlich viele beeindruckende Effekte
verwirklichen.

2. Herangehensweise

Bevor wir den ZBuffer auslesen können brauchen wir natürlich zumindest einen Teil der fertigen Szene, das geschieht automatisch sobald wir unsere Szene rendern (ohne hätten wir einen möglicherweise leeren ZBuffer was nutzlos ist).

Mit dieser Szene können wir nun arbeiten, indem wir ein vor transformiertes Quad
über den Bereich rendern den wir vom ZBuffer auslesen wollen, dabei ist
zu beachten das hier folgende Schritte ideal wären:

1. Bereich sichern (um ihn gegebenenfalls restaurieren zu können falls die Szene
noch nicht angezeigt wurde)

2. den Testbereich mit einem schwarzen vor transformierten Quad ohne ZBuffer Tests und Writes "füllen"

3. den Testbereich mit einem monochrom texturierten vor transformierten Quad mit ZBuffer Tests und ohne Writes überzeichnen.

Je nach ZBuffer Testwert und Tiefen wert des vor transformierten Quads enthält der Testbereich nun ein vermutlich verdecktes Abbild unserer Testtextur vom Quad was wir soeben gerendert haben.

4. den Testbereich in eine Textur zwischen lagern, dieser Texturbereich sollte sollte für Bereiche außerhalb des Testbereiches (zB wenn wir teilweise außerhalb des Backbufferbereiches testen) schwarz sein. Wenn möglich sollte die Textur lockbar sei um die Werte auslesen zu können.

5. wenn nötig den Testbereich mit der Textur aus Schritt 1 restaurieren.

Damit haben wir alle Daten welche wir benutzen können um unsere ZBuffer Readback Informationen zu sammeln und noch einiges mehr.

3. Informationen

Mit der Testbereichstextur können wir nun ermitteln wie stark der Bereich den wir getestet haben im ZBuffer belegt sind (schwarze Stellen sind zB belegt).Dafür locken wir die Textur und summieren alle Pixelfarbwerte (Bereich: 0.0 bis 1.0) zusammen und Teilen diesen Wert durch die Fläche des Testbereiches.

Mit dieser Information können wir zB ermitteln wie viel Prozent des Testbereiches vom ZBuffer belegt sind. Diese Information können wir zB verwenden um einen Lensflareeffekt je nach Verdeckung der Lichtquelle durch die Szene
stärker oder schwächer erscheinen zu lassen (aus bei 0% und max bei 100% Verteilung).

Wir haben aber noch unsere Testbereichstextur selbst, diese können wir verwenden um einen simplen Lightshaft Effekt zu erreichen.

Dazu wird die Textur einfach mit Hilfe eines vor transformierten Quads additiv mehrere male übereinander gerendert, bei jeder Schicht wird dabei die Intensität (erreichbar durch Multiplikation mit zB Vertexfarben) verringert und das Quad
vergrößert.

Ein tolles Beispiel dafür ist zb Halo oder Desperados2 wenn man durch ein Blätterdach in die Sonne schaut, die Strahlen werden dabei ansehnlich von Objekten in der Szene blockiert.

Die Kombination von Lensflares und Lightshafts sorgt dabei für ein wunderbares Grafisches Erlebnis.

4. Testtexturen

Wie erwähnt hier noch eine kleine Erklärung wie eine Testtextur aussehen kann.

Die simpelste Textur ist 1x1 groß und ist rein weiß, diese Textur kann dabei bestenfalls verwendet werden um simple zahlen werte zu erhalten.

Besser jedoch ist eine schwarze Textur welche vom Zentrum bis zum Rand einen weißen Radialen Verlauf aufweist. Dies bietet erstens eine schöne transition zwischen Rand und Zentrum was ideal für Lichter geeignet ist und erlaubt es
außerdem die besprochenen Lightshafts besser darzustellen.

Auch Texturen welche geometrische Körper abbilden (am besten einheitlich
gefärbt) und animiert werden können phantastische Effekte herbeiführen,
zB das diese Geometrische Form stark zu glühen scheint, Grenzen sind nur
von der Phantasie gesetzt.

- Ende

Fragen, Kommentare, Kritik sind immer wieder gern gesehen.

mfg Mark
_________________
"I have a Core2Quad at 3.2GHz, 4GB of RAM at 1066 and an Nvidia 8800 GTS 512 on Vista64 and this game runs like ass whereas everything else I own runs like melted butter over a smokin' hot 18 year old catholic schoolgirl's arse."

[Otscho]

Wo hab ich dann konkret die Tiefe am Punkt x,y ?
Dies wär nämlich sehr sinnvoll wenn man wissen will auf welches Objekt mit der Maus geklickt wurde.

[Fallen]

Ich glaube für das was du machen möchtest gibt es weit aus bessere Methoden. Wenn du aber darauf bestehst wirklich direkt mit dem Tiefenpuffer zu arbeiten dann geht das auch, du musst einfach ein Lockbaren Tiefenbuffer erstellen und ihn wenn nötig locken/unlocken um die Werte auszulesen.

Besonders wichtig ist dabei das die Werteverteilung nicht unbedingt linear ist. So ist es durchaus möglich das Objekte die weiter vorne gerendert werden mehr Werte einnehmen als Objekte die weiter hinten gerendert werden, man müsste also die ausgelesenen Werte weiter verarbeiten.

Wie du siehst ist das ganze eine böse Sache. Die Tiefenwerte in eine seperate Textur zu rendern ist da vermutlich besser.

In dem Fall war die Einleitung zu diesem Tutorial wohl etwas falsch.
_________________
"I have a Core2Quad at 3.2GHz, 4GB of RAM at 1066 and an Nvidia 8800 GTS 512 on Vista64 and this game runs like ass whereas everything else I own runs like melted butter over a smokin' hot 18 year old catholic schoolgirl's arse."

[Otscho]

[Fallen]

Du berechnest zuerst die 3D Koordinaten aus der Position deines Klicks und von da schiesst du einen Strahl in deine Welt und prüfst alle relevanten Objekte ob der Strahl dieses Objekt schneidet. Ist dem so fügst du das Objekt einer Liste von getroffenen Objekten hinzu inklusive Trefferpunkt und evtl die Distanz zu der Camera.

Dann wertest du diese Daten aus (das Objekt welches am nächsten zur Kamera ist wurden gepickt).

Schaue einfach mal in goofle nach "picking" da sollte es einige Treffer geben. Am besten machst du dazu noch einen eignen Thread auf da es dazu eine Menge zu besprechen geben könnte und es nicht unbedingt hier rein gehört

mfg Mark
_________________
"I have a Core2Quad at 3.2GHz, 4GB of RAM at 1066 and an Nvidia 8800 GTS 512 on Vista64 and this game runs like ass whereas everything else I own runs like melted butter over a smokin' hot 18 year old catholic schoolgirl's arse."

[Otscho]

So hab ich mir das auch schon gedacht, nur ein Mausklick in einer 2D-Ebene spuckt wie du schon gesagt hast eine Gerade an Lösungen aus. Wenn man jetzt noch die Entfernung des Punktes wüsste hätte man schon einen 3D-Punkt mit x, y, z was das suchen von Objekten deutlich vereinfache .
Aber Danke für deine Hilfe

[Jonathan_Klein]

äh, nein.
Du musst bedenken, das ganze ist perspektivisch. Außerdem sind die Mauskoordinaten ja z.. von 0-1024 und 0.768, Dass hat in den meisten Fällen rein gar nichts mit den dreidimensionalen Koordinaten eines Objektes zu tun.
Deine Idee, aus der Mausposition den X und Y Wert zu bestimmen, und dann zu schauen, welches ZWert dort ist, funktioniert nur bei orthogonaler Projektion, und bei der braucht man das z Gehampel normalerweise gar nicht.
Du musst schon die Lösung mit dem Strahl nehmen.
_________________
https://jonathank.de/games/