Guten Nachmittag OGL-Community,

Ich arbeite seit einiger Zeit an einem Spiel (http://www.delphipraxis.net/159339-shape-wars-version-1-2-1-a-7.html). Hierbei gibt es verschiedene Gegner, und um jeden Gegner sind sozusagen Lichtkreise, die den Hintergrund beleuchten. Im moment habe ich das einfach über additives Blending gelöst, jetzt möchte ich allerdings, dass diese Lichtkegel als Alpha-Kanal für alles, was dahinter liegt benutzt wird. Also dass ohne irgendeinen Gegner der Hintergrund unsichtbar ist, und nur um einen Gegner ein Teil des Hintergrundes sichtbar ist. Also so als wäre in Photoshop der Ebenenmodus auf Multiplizieren gestellt.

Hier mal eine kleine Visualisierung des Problems:


Lg, Edlmann

schwer da jetzt das Optimum zu bestimmen ohne genauer deinen Code gelesen zu haben. In der Regel würde ich zuerst die Lichtkegel rendern
und anschließend halt die "Welt" mit den Parametern GL_DST_ALPHA ,GL_ONE "draufblenden"....
[edit] ups

_________________
Meine Homepage

Möglichkeit 1:
a) Graustufen-Licht:
Lichtkreise in den Alpha-Kanal des Framebuffers rendern (0 = schwarz, 255 = Hintergrund sichtbar)
Hintergrund rendern mit glBlendFunc(GL_DST_ALPHA, GL_ZERO);
Gegner rendern mit glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

b) Farbiges Licht:
Lichtkreise in die RGB-Kanäle des Framebuffers rendern (0 = schwarz, 255 = Hintergrund sichtbar)
Hintergrund rendern mit glBlendFunc(GL_DST_COLOR, GL_ZERO);
Gegner rendern mit glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

Die Methoden 1a) und 1b) liefern keine korrekte Beleuchtung (bezüglich der Lichtkreise) für den Gegner. Dieser ist einfach voll beleuchtet. Sofern es sich simple texturierte Quads handelt könnte die Beleuchtung aber natürlich einfach gleich in die Gegner-Textur mit einbauen.

Möglichkeit 2: (Graustufen-Licht)
glClearColor(0,0,0,0); // Default, wichtig ist das Alpha = 0, alles andere egal
glClear(GL_COLOR_BUFFER_BIT); // ggf. GL_DEPTH_BUFFER_BIT und GL_STENCIL_BUFFER_BIT gleich mit
glColorMask(true, true, true, false);
Hintergrund rendern
Gegner rendern (mit glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) falls transparent)
glColorMask(false, false, false, true);
Lichtkreise mit glBlendFunc(GL_ONE, GL_ZERO) in den Alpha-Kanal des Framebuffers rendern (0 = schwarz, 255 = Hintergrund sichtbar)
glColorMask(true, true, true, true);
Ein Quad über den gesamten Bildschirm legen, mit glBlendFunc(GL_ZERO, GL_DST_ALPHA)

Möglichkeit 3: (echtes Licht)
Du kannst natürlich auch einfach deine Szene mit echten Lichtquellen rendern. Allerdings unterstützt die FFP von OpenGL nicht mehr als 8 Lichtquellen gleichzeitig. Wenn du mehr Lichtquellen (Gegner im Bild) benötigst solltest du auf Shader zurückgreifen. Damit sind auch hunderte Lichtquellen kein Problem, wenn du es richtig anstellst. Vorteil dieser Methode ist, dass du unter Umständen komplett auf Blending verzichten kannst und die Szene in einem Rutsch rendern. Des weiteren ist sie bei geschickter Shader-Programmierung natürlich effizienter. Darüber hinaus sind natürlich tolle Shader-Effekte wie Bumpmapping ganz leicht möglich.

Möglichkeit 4: (Offscreen Lichttextur)
Im wesentlichen das gleiche wie Möglichkeit 2, allerdings ist auch farbiges Licht möglich.
1. Szene mit voller Helligkeit normal rendern
2. Lichtquellen in einen FBO rendern. Dies kann eine Graustufen- oder Farbtextur sein.
3. Mittels Blending die Lichttextur auf die Szene multiplizieren: glBlendFunc(GL_ZERO, GL_SRC_COLOR)



Möglichkeit 2 und 4 sind wahrscheinlich am besten geeignet. Eventuelle Fehler vorbehalten, probiert habe ich obiges nicht

_________________
Yeah!

Vielen Dank für die Antworten

Möglichkeit 3 fällt weg, weil ich mich mit Shadern noch kaum beschäftigt habe, und teilweise über 200 Gegner auf dem Spielfeld sind

Von daher werd ich mich mal dransetzen, die Möglichkeit mit der FBO zu implementieren, funktioniert soweit auch schon wunderbar in einer Test-Applikation,

Vielen Dank nochmal und LG,
Edlmann

Okey, das mit der Offscreen-Lichttextur funktioniert zwar wunderbar, wird bei mehreren Hundert Lichquellen aber zum ziemlichen Ressourcenvernichter.
Von daher müsste ich wahrschienlich um das zu realisieren auf die Möglichkeit mit den Shadern zurückgreifen, allerdings sind meine ersten Versuche mit Shadern eher kläglich. Ich verstehe zwar die Shaderbeispiele alle, doch sobald ich einen eigenen Shader schreiben will, krieg ich es irgendwie nicht hin...Wäre super wenn einer von euch sich die Mühe machen könnte und mir das Konzept für einen Shader erklären könnte, der mehrere hundert Lichtquellen unterstützt...Ich habe im Moment absolut keinen Plan, wie man überhaupt die Positionen von mehreren Hundert Lichtern an den Shadern übergeben kann...

Lg, Edlmann

Hm, vielleicht solltest du nen Sichtbarkeitscheck für deine Lichtquellen einbauen? Bedenke auch, dass du erst bequem alle in das FBO rendern kannst und dann nur einmal rüberblenden musst. Also eigentlich sollten 100 Lichtquellen, die aus je einem Quad mit Textur bestehen und additiv geblendet werden, kein Problem sein.

greetings

_________________
If you find any deadlinks, please send me a notification – Wenn du tote Links findest, sende mir eine Benachrichtigung.
current projects: ManiacLab; aioxmpp
zombofant network • my photostream
„Writing code is like writing poetry“ - source unknown

„Give a man a fish, and you feed him for a day. Teach a man to fish and you feed him for a lifetime. “ ~ A Chinese Proverb

Der Sichtbarkeitscheck ist überflüssig, da ich ja nur in einem 2D-Raum arbeite und 75% des Spielfeldes immer Sichtbar sind, sprich damit würde nicht so viel eingespart werden...Ich hatte das gerade aber einmal eingebaut mit nem FBO, wodurch die Grafikkarten-Auslastung des Spiels von vorher 6-10% auf 20-25% Anstieg, und da das Spiel auch auf älteren Rechnern spielbar sein soll (ich besitze eine GTX 460), ist das nicht gerade optimal...So wie ich es bisher mache, dass nur die Lichter hinter den Gegnern gerendert werden, hält sich die Auslastung in Grenzen...Das problem ist, dass wenn ich diese Sichtbarkeit des Hintergrundes einbaue, auch um die Partikel ein kleiner Schein sein sollte, wodurch die Anzahl der Lichter sich vervielfacht (maximal sind so 1000 Partikel sichtbar), und das ist nicht mehr Performant mit Texturen zu lösen...

Ich denke du machst irgendwas beim rendern in den FBO falsch. Jede Lichtquelle sollte nur ein Quad sein welches mit einer entsprechenden Textur bespannt ist. Diese Textur kann höchstwahrscheinlich für alle Lichtquellen gleich sein.

Du benutzt den Immediate Mode? (also glBegin() und glEnd()?) Wenn ja rendere wenigstens alle deine Licht-Quads innerhalb eines glBegin()-glEnd() Blocks. Besser ist es einen VBO zu benutzen, bringt hier aber nur wenig da sich die Gegner vermutlich bewegen und daher der Buffer eh ständig neugeschrieben werden muss. (In anderen Fällen ist ein VBO aber massiv schneller)

Was ich mir sonst noch vorstellen könnte wäre das du eine Quads mit einer übertrieben großen Textur bespannst ohne Mipmaps zu erzeugen.

Falls es das nicht ist, check auf mal diesen Artikel ob dir sonst noch irgendwas ins Auge springt:
http://wiki.delphigl.com/index.php/Performance


Das war eine Anspielung auf Deferred_Shading. Für deinen Spezialfall ist das jetzt nicht so der Anwendungsfall. Deferred Shading macht Sinn bei wirklich extrem komplexer Geometrie die du nicht mehrfach rendern kannst.


Z.B. auf meiner Geforce 9800 GT kannst du im Fragmentshader bis zu 2048 vec4 als Uniform übergeben. Das würde in der Theorie für 2000 Lichtquellen reichen (Position + Radius jeweils in ein vec4 quetschen). Ein paar Uniforms werden immer für andere Dinge gebraucht. Wenn du mehr Daten übergeben willst kannst du dies in Form einer Textur machen. Du kannst im Shader ja auf beliebige Stellen in einer Textur zugreifen und es gibt natürlich auch Texturen mit Float statt Byte als Datentyp.
=> Also du kriegst die Daten schon in den Shader, aber die Datenmenge ist zu groß um sie einfach mit einer Schleife abzuarbeiten. 100 Lichtquellen könnte noch klappen...bei mehr wird's kritisch. Da muss man schon etwas Grips anwenden. Du musst in irgendeiner Form dafür sorgen das nicht jede Lichtquelle für jeden Pixel verarbeitet wird. Hier hilft eben der Ansatz die Lichtquellen als kleine Quads zu rendern. Eine andere Möglichkeit wäre die Implementierung einer Baumstruktur (kd-Tree) für die Lichtquellen im Shader, aber das ist für deinen Fall wirklich absoluter Overkill.

Wie gesagt: Möglichkeit 4 ist für deinen Fall wahrscheinlich am besten geeignet. Die Verwendung von Shadern ist hier nicht ausgeschlossen. Mit einem Shader könnte man sich etwa den 3. Pass sparen. Du würdest zuerst die Lichttextur erzeugen und dann im Fragmentshader beim rendern der restlichen Szene darauf zugreifen. (Aus gl_FragCoord und der Größe des Viewports kannst du dir Texturkoordinaten für die Lichttextur berechnen)

_________________
Yeah!

Die Größe der Texturen ist kein Problem, diese liegt bei 128*128, und gerendert wird auf einen Bereich der 150*150 Einheiten groß ist. Das ist schon soweit alles in Ordnung. Was aber wirklich sein könnte, ist dass ich für jedes Quad wieder ein glBegin-glEnd Block hatte...Werds gleich nochmal umschreiben und dann mal schauen wie das von der Performance her aussieht.
Hab auch eine Idee wie ich das mit den Partikeln zur Not lösen kann, da ich Partikelexplosionen habe, kaum einzelne Partikel, könnte man einfach ein großes Licht hinter die Partikel rendern, dürfte einen ähnlichen Effekt haben.

Lg, Edlmann

Ich weiß einfach nicht wo mein Fehler liegt...so wie ich es vorher hatte liegt die Graka-Auslastung deutlich niedriger als bei der Version mit FBO. Ich hab mal eine Version hochgeladen, wo beides drin ist, wäre super wenn ihr euch die mal anschauen könntet beide und schauen könntet, welche bei euch besser läuft, ist ja von Graka zu Graka unterschiedlich.

http://dl.dropbox.com/u/12342503/ShapeW ... ghting.rar

Und da ich einfach nicht weiß was ich falsch mache, hab ich mich mal entschieden etwas von meinem Quelltext zu veröffentlichen. Das FBO Render ich mit folgender Prozedur:



WObei Lights ein array ist, welches die Daten des Lichts enthält. Diese werden geschrieben, während die Gegner etc gerendert werden, so dass nicht 2x auf die gesamte Gegnerklasse zurückgegriffen werden muss, sondern zum Lichter rendern einfach das Array durchgegangen werden kann.
Über die Szene blende ich es mit folgendem Code:



Aber wie gesagt, die Performance ist gelinde gesagt mäßig. Vorher habe ich die Lichter wie folgt gerendert:



Wobei ich hier noch nichteinmal drauf geachtet habe, das ganze in einen einzigen glBegin-End block zu packen, es läuft aber trotzdem deutlich besser...In der Prozedur DrawQuad wird über 3D-Vertexe ein Quad gerendert mit glBegin und glEnd in der Prozedur selbst, bei der Prozedur die ich für das FBO benutze (Draw2DQuad) werden nur 2D-Vertexe aufgerufen, und das glBegin/End ist nicht enthalten, sodass es dort nur einmal aufgerufen wird.

Ich versteh einfach nicht warum das eine so viel schlechter performt als das andere, ich hoffe ihr könnt mir helfen,
Lg, Edlmann

Du erzeugst in jedem Frame die Mipmaps für die Lichttextur neu.


Das ganze kann auch nicht genauso schnell sein. Bei der FBO-Methode fasst du quasi jeden Pixel dreimal an, bei deiner ursprünglichen Methode aber nur 1-2mal.

Wenn eine Grafikkarte nicht ausgelastet ist (so wie hier...die GTX 460 sollte sich gerade zu langweilen) sind irgendwelche Performance angaben übrigens nicht wirklich zuverlässig.

_________________
Yeah!

Das mit den Mipmaps habe ich erstmal testweise eingebaut, war vorher draußen, die gesamtauslastung ist allerdings gesunken nachdem ich die Mipmaps wie hier
erzeugt habe... ^^
Und ich hab die Performance auf 2 Arten getestet, zum einen mit aktiviertem V-Sync, und dann mithilfe von EVGA-Precision die GPU-Auslastung auslesen lassen, und mit
deaktiviertem V-Sync, wobei ich dann die maximale Framerate als Kriterium benutzt habe...Und bei Methode 1 hat die FBO-Methode doppelt so viel Auslastung erzeugt wie
meine alte Methode, bei der 2. war die Framerate ca halb so hoch mit FBO...aber was ich grade überlegt habe, könnte man nicht eigenlich das FBO auch rauslassen,
und einfach in meine ursprüngliche Licht-Render-Methode die Texturen mit der Function glBlendFunc(GL_ZERO, GL_SRC_COLOR); drüberblenden, wobei man vorher
ein schwarzes Quad dazwischenrendert? Das müsste vom Ergebnis her doch dasselbe sein wenn ich mich nicht irre.

Halb soviel von wie viel? Ein FBO-Wechsel ist ja quasi ein Frame...das sollte dir klar sein. Aktuell machst du in einem solchen Frame relativ wenig, während der Framewechsel selbst schon recht viel Overhead hat.


Liegt daran wie deine Gegner bzw. der Hintergrund gerendert werden. Ich bin davon ausgegangen das du diese Deckend über dem Hintergrund haben willst, eben nicht mit dem Hintergrund multipliziert. Ansonsten siehe Methode 1b), wo du dann die Beleuchtung direkt in die Gegnertextur einbauen musst.

_________________
Yeah!