© Liashko/Shutterstock.com
Teil 3: Motion Blur, Flimmern, Depth of Field, God Rays und Lens Flares

Göttliche Weltraumeffekte


Cinematografische Effekte gehören zu den Must-have-Features moderner Computerspiele. Im heutigen Artikel gehen wir der Frage nach, wie sich Motion Blur, Hitzeflimmern, Depth of Field, God Rays und Lens Flares in eine bestehende Deferred Render­ing Pipeline integrieren lassen.

Die Einführung des Shader-Models 3.0 im Rahmen der DirectX-Version 9c und die Veröffentlichung der OpenGL-Spezifikation 2.0 im Jahr 2004 bereiteten das Fundament für eine regelrechte Revolution im Bereich der Echtzeitgrafikprogrammierung, die zu einer grundlegenden Änderung der 3-D-Szenendarstellung führen sollte. So genannte Deferred Rendering Pipelines ersetzten zusehends das in Game Engines bisher übliche Forward Rendering (die zeitgleiche Positionierung und Beleuchtung von 3-D-Objekten), da sie einerseits eine deutlich realistischere Beleuchtung und andererseits die Implementierung einer Vielzahl von coolen Post-Processing-Effekten, darunter Unschärfe- und Verzerrungsfilter, wie Motion Blur, Depth of Field und Hitzeflimmern oder Lichteffekte wie God Rays und Lens Flares, ermöglichten.

Große Macht bringt große Verantwortung

Spieleentwickler neigen im Eifer des Gefechts gerne mal zu Übertreibungen. In den Anfangszeiten des HDR-Renderings (HDR: High Dynamic Range) beispielsweise klagten viele Spieler über die viel zu intensiven Blend- und Glanzeffekte. Und auch heute noch ist die nachfolgende Aussage sicher nicht ganz von der Hand zu weisen: „Würde uns die reale Welt erscheinen, als entstamme sie einem Computerspiel, dann nichts wie hin zum Augenarzt!“

Verstehen Sie mich bitte nicht falsch: Mit Bedacht eingesetzte Spezialeffekte sind eine Bereicherung für jedes Computerspiel. Übertreibt man es jedoch, dann verkehrt sich ihre Wirkung schnell ins Gegenteil. Nicht nur, dass man diese grafischen Spielereien dann als störend empfindet, es gibt auch Spieler, die nach einiger Zeit sogar über Kopfschmerzen oder Übelkeit (Motion Sickness) klagen. Sowohl beim Motion-Blur- (Bewegungsunschärfe) wie auch beim Depth-of-Field-(Schärfentiefe)Effekt werden Teile des Bilds unscharf dargestellt. Die besagten gesundheitlichen Probleme sind nun das Resultat der permanent zum Scheitern verurteilten Versuche des menschlichen Auges, diese unscharfen Bildausschnitte irgendwie scharfzustellen (zu fokussieren). Und wer nun denkt, alle Spieleentwickler gingen verantwortlich mit dem Einsatz von Unschärfe- und Überblendungseffekten um, kann sich durch eine Google-Suche mit den Stichwörtern „disable motion blur“ oder „Unschärfeeffekt abschalten“ eines Besseren belehren lassen. Auch bei aktuellen Spieletiteln ist es nicht immer ganz leicht und manchmal sogar unmöglich, die Unschärfeeffekte den eigenen Vorlieben entsprechend anzupassen – was nicht zuletzt daran liegt, dass diese gerne mal missbraucht werden, um über die grafischen Unzulänglichkeiten eines Spiels bzw. der Hardware hinwegzutäuschen. Selbstverständlich wünschen wir uns alle möglichst realistische Spielewelten und enorme Weitsicht bei gleichzeitig hohen Frameraten. In der Realität müssen wir jedoch einige Abstriche in Kauf nehmen.

Natürlich kommt man als Spieleentwickler nicht umhin, den Detailgrad der Umgebung mit zunehmendem Kameraabstand nach und nach zu reduzieren, und natürlich lassen sich gelegentliche Ruckler beim Bildaufbau nicht völlig vermeiden. Wir können jedoch dafür Sorge tragen, dass der Spieler möglichst wenig davon mitbekommt. Mithilfe eines dezent eingesetzten Depth-of-Field-Effekts lässt sich beispielsweise die zunehmende Detailarmut im Hintergrund kaschieren. Jedoch darf man dem Spieler zu keinem Zeitpunkt das Gefühl vermitteln, er sei plötzlich kurzsichtig geworden. Wird das Bild bereits nach wenigen (dutzend) Metern sichtlich unscharf, dann ist die Spielfreude schnell dahin. Genau das Gleiche geschieht bei dem Versuch, die Auswirkungen einer konstant niedrigen Framerate bzw. die von kurzzeitigen Einbrüchen (Ruckler) durch Einsatz von Motion Blur abzuschwächen. Schießt man als Programmierer über das Ziel hinaus, läuft das betreffende Spiel zwar deutlich flüssiger, aber dafür wirkt die Umgebung selbst bei kleinsten Bewegungen verwaschen und unscharf.

Der permanente Einsatz des Depth-of-Field-Effekts ist generell nicht ganz unproblematisch, denn um die Schärfentiefe glaubhaft simulieren zu können, müssten wir zuvor erst einmal die korrekte Blickrichtung des Spielers ermitteln. Da dies jedoch zurzeit nicht möglich ist, bleibt nur der Griff in die Trickkiste. Nimmt man beispielsweise an, ein Spieler würde die meiste Zeit in Richtung Bildschirmmitte blicken – was natürlich nicht stimmt –, ließe sich die Kamera auf die dortigen Objekte fokussieren. Es ist jedenfalls keine zufriedenstellende Lösung (und für viele Spieler schlicht inakzeptabel), einfach den kompletten Hintergrund unscharf darzustellen.

Auch beim Einsatz von Motion Blur gibt es einiges zu beachten: Für die glaubhafte Simulation eines Geschwindigkeitsgefühls ist es notwendig, sowohl die Kamerabewegung als auch die Relativgeschwindigkeiten und Kameraabstände aller Szenenobjekte bzw. Szenenpixel zu berücksichtigen. Tunneleffekte in Rennspielen, bei denen die Objekte in der Bildschirmmitte scharf gezeichnet werden und die Ränder verwischen, wären ansonsten nicht möglich. Würde man in die Unschärfeberechnung lediglich die Kamerabewegung einbeziehen, käme es zwangsläufig zu Renderfehlern. Ein typisches Beispiel hierfür wären unscharf dargestellte Waffen, wenn der Spieler in einem Ego-Shooter seine Blickrichtung ändert. Für Spezialeffekte wie Bewegungsspuren ist es zudem erforderlich, dass die Bewegungsunschärfe für einzelne Szenenobjekte/Szenenpixel selektiv generiert werden kann.

Extreme Bildunschärfen sollten mit Bedacht und in Form von Spezialeffekten immer nur für einen kurzen Zeitraum eingesetzt werden, beispielsweise

  • wenn sich ein Raumschiff mit Warp-Geschwindigkeit vom Spieler entfernt und dabei eine Science-Fiction-Film-typische Bewegungsspur (selektiver Motion Blur) hinterlässt.

  • wenn der Spieler-Avatar verletzt wird (eine Kombination von Motion Blur und Kurzsicht-Depth-of-Field-Effekt getreu dem Motto: „Nach einem Schlag auf den Kopf nimmt man die Umgebung eine Zeitlang verschwommen wahr.“).

  • wenn man durch ein Zielfernrohr blickt (Fernsicht-Depth-of-Field-Effekt: Die nähere Umgebung erscheint unscharf, nur die Details in größerer Entfernung lassen sich genau erkennen).

  • bei Interaktionen mit einer anderen Spielfigur (Kurzsicht-Depth-of-Field-Effekt: Die Kamera wird auf den Gesprächspartner fokussiert, alles Weitere wird verschwommen dargestellt).

  • als Stilmittel, um Zwischensequenzen (Cutscenes) interessanter zu gestalten, und um auf bedeutsame Details wie geheime Dokumente und wichtige Gegenstände hinzuweisen (Kurzsicht-Depth-of-Field-Effekt).

Einfache Deferred Rendering Pipeline

Das Herzstück der in unseren OpenGL-Programmbeispielen implementierten Deferred Rendering Pipeline bildet ein in der Literatur als G-Buffer (Geometry Buffer) bezeichnetes Frame-Buffer-Objekt, an das wir insgesamt fünf Texturen (Render Targets) zum Speichern aller Geometrie- und Farbinformationen einer 3-D-Szene binden:

  • Textur 1: Die texturierten, jedoch nicht beleuchteten sichtbaren Szenenpixel (PrimaryScreenTexture)

  • Textur 2: Kameraraumpositionen und Tiefenwerte der sichtbaren Szenenpixel (SceneCameraSpacePos­AndDepthTexture)

  • Textur 3: Kameraraumnormalen der sichtbaren Szenenpixel (CameraViewNormalTexture)

  • Textur 4: Reflektionsvermögen (Farbe und Intensität) der sichtbaren Szenenpixel (CameraViewSpecularTexture)

  • Textur 5: Selbstleuchtende Szenenpixel (z. B. mittels Light Map beleuchtet) (CameraViewEmissiveTexture)

Nach Abschluss der Geometrieverarbeitung können wir dann im Verlauf der Post-Processing-Phase auf diese Daten zugreifen und in mehreren Schritten das endgültige Szenenbild berechnen.

Bevor wir gleich tiefer in die einzelnen Post-Processing-Berechnungen einsteigen, werden wir uns zunächst einmal damit befassen, wie die Darstellung einer 3-D-Szene im Rahmen des Deferred Renderings vonstattengeht und in diesem Zusammenhang die hierfür erforderlichen Schritte anhand eines einfachen Beispiels gemeinsam durcharbeiten (Kasten: „Ein Beispiel in einzelnen Schritten“).

Ein Beispiel in einzelnen Schritten

Schritt 1: Lichteigenschaften für die Szenenbeleuchtung festlegen und den neuen Render-Durchgang vorbereiten:

PostProcessingEffects->Reset_ScreenSpaceLights();
PostProcessingEffects->Add_Light(...);
PostProcessingEffects->Prepare_DeferredLighting(&g_BackgroundScreenColor);

Schritt 2: Hintergrunddarstellung:

PostProcessingEffects->Continue_SceneRendering(RM_SceneColorOnly);
SkyBox->Render_BackgroundBox(...);
PostProcessingEffects->Stop_SceneRendering();

Schritt 3: Terrain und andere undurchsichtige (opake) Szenenobjekte rendern:

PostProcessingEffects->Continue_SceneRendering(RM_ScreenSpaceLighting);
[Terrain und andere undurchsichtige Szenenobjekte rendern]
PostProcessingEffects->Stop_SceneRendering();

Schritt 4: Ambient-Occlusion-, Beleuchtungs- sowie Schattenraumberechnungen (VolumetricLightScattering, God-Ray-Effekt) durchführen:

PostProcessingEffects->Calculate_ScreenSpaceAmbientOcclusion(...);
PostProcessingEffects->Calculate_ScreenSpaceLighting(&g_CameraViewDirection);
 
PostProcessingEffects->Calculate_ComplexVolumetricLightScattering(
&g_LightScatteringParameter, &g_LightScatteringPrimaryColorFilter,
&g_LightScatteringSecondaryColorFilter, &LightWorldPos, &g_CameraViewDirection,
&g_ViewProjectionMatrix, &g_CameraPosition);

Schritt 5: Transparente Objekte (beispielsweise Partikel) rendern, sofern diese bei den Motion-Blur- bzw. Depth-of-Field-Berechnungen berücksichtigt werden sollen:

if(g_CameraMovement == true)
{
  PostProcessingEffects->Continue_SceneRendering(RM_SceneColorOnly);
  [Partikeleffekte rendern]
  PostProcessingEffects->Stop_SceneRendering();
}

Schritt 6: Motion-Blur- sowie Depth-of-Field-Berechnungen durchführen:

if(g_CameraMovement == true)
  PostProcessingEffects->Calculate_MotionBlur(0.65f, false);
 
// Weitsichtigkeit:
if(g_ShortSightedDepthOfFieldEffect == FALSE)
PostProcessingEffects->Calculate_DepthOfFieldEffect(false, 1.0f, 200.0f,
                                                    1000.0f, 10.0f, true);
 
// Kurzsichtigkeit:
else if(g_ShortSightedDepthOfFieldEffect == TRUE)
  PostProcessingEffects->Calculate_DepthOfFieldEffect(true, 1.0f, 10.0f,
                                                    500.0f, 10.0f, true);

Schritt 7: Verzerrungseffekte simulieren (z. B. Hitzeflimmern):

if(g_CameraMovement == false)
{
  PostProcessingEffects->Begin_SecondarySceneRendering(&g_BackgroundScreenColor);
  [Partikel in die zweite Screen-Textur (Auflösung 64x64 Pixel) rendern]
  PostProcessingEffects->Stop_SecondarySceneRendering();
 
  // Verzerrungseffekte (Flimmern und Unschärfe) berechnen:
  PostProcessingEffects->Combine_Primary_And_Secondary_ScreenTexture(
  &D3DXVECTOR4(frnd(g_MinDistortionX, g_MaxDistortionX),
               frnd(g_MinDistortionY, g_MaxDistortionY),
               g_DistortionInvWavelength,
               g_DistortionFrequency*GetTickCount()));
}

Schritt 8: Komplettieren des ersten Render-Durchgangs. Das fertig berechnete Szenenbild wird als Textur auf ein bildschirmfüllendes Vertexquad gemappt und für die Motion-Blur-Berechnungen im nächsten Frame zwischengespeichert:

PostProcessingEffects->Render_PrimaryScreenQuad(...);
 
if(g_CameraMovement == true)
  PostProcessingEffects->Prepare_MotionBlur_ForNextFrame(false);

Schritt 9: Darstellung aller transparenten Szenenobjekte (Explosionen, Feuer, Partikel, Lens Flares usw.), die einen Einfluss auf die vom Auge wahrgenommene Helligkeit haben (zweiter Render-Durchgang):

PostProcessingEffects->Prepare_SceneRendering(&g_BackgroundScreenColor);
 
if(g_CameraMovement == false)
{
  PostProcessingEffects->Continue_SceneRendering(RM_SceneColorOnly);
  [Partikeleffekte...

headline from sands settings