Technische Darstellungslehre 2 - Exam

Aufgabe 1)

Dateninterpolation und -extrapolationInterpolation schätzt Werte innerhalb eines bekannten Wertebereichs. Extrapolation schätzt Werte außerhalb des bekannten Wertebereichs.

• Interpolation: Nutzt bekannte Datenpunkte, um unbekannte Werte dazwischen zu berechnen.
• Methoden: Lineare Interpolation, Polynomiale Interpolation.
• Extrapolation: Nutzt Trends oder Muster der bekannten Daten, um Werte außerhalb zu schätzen.
• Risiko: Höheres Fehlerpotenzial bei Extrapolation wegen Annahmen über unverfügbare Daten.
• Mathematische Formeln:
• Lineare Interpolation:

a)

Gegeben seien die Punkte und Wie lautet der interpolierte Wert an der Stelle ?

Lösung:

Dateninterpolation und -extrapolationInterpolation schätzt Werte innerhalb eines bekannten Wertebereichs. Extrapolation schätzt Werte außerhalb des bekannten Wertebereichs.

• Interpolation: Nutzt bekannte Datenpunkte, um unbekannte Werte dazwischen zu berechnen.
• Methoden: Lineare Interpolation, Polynomiale Interpolation.
• Extrapolation: Nutzt Trends oder Muster der bekannten Daten, um Werte außerhalb zu schätzen.
• Risiko: Höheres Fehlerpotenzial bei Extrapolation wegen Annahmen über unverfügbare Daten.
• Mathematische Formeln:
• Lineare Interpolation: \ \[y = y_1 + \frac{{x - x_1}}{{x_2 - x_1}} \cdot (y_2 - y_1)\]

Teilaufgabe:Gegeben seien die Punkte \(x_1, y_1\) und \(x_2, y_2\). Wie lautet der interpolierte Wert an der Stelle \(x\)?Lösung:Die Formel zur linearen Interpolation ist: \[y = y_1 + \frac{{x - x_1}}{{x_2 - x_1}} \cdot (y_2 - y_1)\]Um den interpolierten Wert \(y\) an der Stelle \(x\) zu berechnen, musst Du die bekannten Werte von \(x_1\), \(y_1\), \(x_2\) und \(y_2\) in die Formel einsetzen.

• Setze \(x_1\) und \(y_1\) als den ersten bekannten Punkt ein.
• Setze \(x_2\) und \(y_2\) als den zweiten bekannten Punkt ein.
• Setze den gewünschten Interpolationspunkt \(x\) ein.
• Berechne den interpolierten Wert \(y\).

b)

Berechne den extrapolierten Wert an der Stelle, wenn die Steigung beträgt.

Lösung:

Dateninterpolation und -extrapolationInterpolation schätzt Werte innerhalb eines bekannten Wertebereichs. Extrapolation schätzt Werte außerhalb des bekannten Wertebereichs.

• Interpolation: Nutzt bekannte Datenpunkte, um unbekannte Werte dazwischen zu berechnen.
• Methoden: Lineare Interpolation, Polynomiale Interpolation.
• Extrapolation: Nutzt Trends oder Muster der bekannten Daten, um Werte außerhalb zu schätzen.
• Risiko: Höheres Fehlerpotenzial bei Extrapolation wegen Annahmen über unverfügbare Daten.
• Mathematische Formeln:
• Lineare Interpolation: \ \[y = y_1 + \frac{{x - x_1}}{{x_2 - x_1}} \cdot (y_2 - y_1)\]

Teilaufgabe:Berechne den extrapolierten Wert an der Stelle \(x\), wenn die Steigung \(m\) \(y_2 - y_1\) beträgt.Lösung:Um den extrapolierten Wert zu berechnen, kannst Du die Geradengleichung in Punkt-Steigungs-Form verwenden. Die allgemeine Form ist: \[y = y_1 + m(x - x_1)\]Schritte zur Berechnung:

• Identifiziere den gegebenen Punkt \(x_1, y_1\).
• Verwende die gegebene Steigung \(m\).
• Setze den Wert für \(x\) ein, an dem Du den extrapolierten Wert berechnen möchtest.
• Berechne den extrapolierten Wert \(y\) mit der Formel \(y = y_1 + m(x - x_1)\).

c)

Erkläre, warum eine polynomiale Interpolation im Allgemeinen genauer ist als eine lineare Interpolation.

Lösung:

Dateninterpolation und -extrapolationInterpolation schätzt Werte innerhalb eines bekannten Wertebereichs. Extrapolation schätzt Werte außerhalb des bekannten Wertebereichs.

• Interpolation: Nutzt bekannte Datenpunkte, um unbekannte Werte dazwischen zu berechnen.
• Methoden: Lineare Interpolation, Polynomiale Interpolation.
• Extrapolation: Nutzt Trends oder Muster der bekannten Daten, um Werte außerhalb zu schätzen.
• Risiko: Höheres Fehlerpotenzial bei Extrapolation wegen Annahmen über unverfügbare Daten.
• Mathematische Formeln:
• Lineare Interpolation: \ \[y = y_1 + \frac{{x - x_1}}{{x_2 - x_1}} \cdot (y_2 - y_1)\]

Teilaufgabe:Erkläre, warum eine polynomiale Interpolation im Allgemeinen genauer ist als eine lineare Interpolation.Lösung:

• Größere Flexibilität: Polynomiale Interpolation nutzt Polynomfunktionen höherer Grade, die besseren Anpassung an die Datenpunkte zulassen. Dadurch kann sie gekrümmte Verläufe und komplexe Muster der Daten präziser erfassen als eine gerade Linie.
• Berücksichtigung mehrerer Punkte: Während die lineare Interpolation lediglich zwei benachbarte Punkte berücksichtigt, kann die polynomiale Interpolation mehrere Punkte in ihre Berechnungen einbeziehen. Dies führt zu einer besseren Annäherung an die tatsächlichen Datenverläufe.
• Glattere Kurven: Polynomiale Interpolation erzeugt Kurven, die glatter und kontinuierlicher sind. Dadurch wird vermieden, dass abrupte Änderungen auftreten, die in realen Daten normalerweise nicht vorkommen.
• Korrekte Modellierung: Vor allem bei Daten, die naturgemäß nicht linear sind, wie z.B. Wachstumskurven oder periodische Signale, bietet die polynomiale Interpolation eine genauere Modellierung.
• Mathematische Tiefe: Ein höhergradiges Polynom kann subtilere Beziehungsverläufe besser approximieren, während lineare Modelle nur einfache lineare Trends darstellen können.

Zusammengefasst bietet die polynomiale Interpolation durch ihre größere mathematische Flexibilität und Fähigkeit, komplexe Zusammenhänge zwischen Datenpunkten abzubilden, häufig eine genauere Schätzung als die einfache lineare Interpolation. Es ist jedoch zu beachten, dass bei zu hohem Polynomgrad auch die Gefahr der Überanpassung (Overfitting) besteht, wobei das Modell zu sehr an die Trainingsdaten angepasst wird und somit die Generalisierungsfähigkeit verliert.

d)

Welche Risiken bestehen bei der Extrapolation und wie kannst Du diesen begegnen?

Lösung:

Dateninterpolation und -extrapolationInterpolation schätzt Werte innerhalb eines bekannten Wertebereichs. Extrapolation schätzt Werte außerhalb des bekannten Wertebereichs.

• Interpolation: Nutzt bekannte Datenpunkte, um unbekannte Werte dazwischen zu berechnen.
• Methoden: Lineare Interpolation, Polynomiale Interpolation.
• Extrapolation: Nutzt Trends oder Muster der bekannten Daten, um Werte außerhalb zu schätzen.
• Risiko: Höheres Fehlerpotenzial bei Extrapolation wegen Annahmen über unverfügbare Daten.
• Mathematische Formeln:
• Lineare Interpolation: \ \[y = y_1 + \frac{{x - x_1}}{{x_2 - x_1}} \cdot (y_2 - y_1)\]

Teilaufgabe:Welche Risiken bestehen bei der Extrapolation und wie kannst Du diesen begegnen?Lösung:

• Risiken bei der Extrapolation:
  • Fehlende Daten: Extrapolation beruht auf der Annahme, dass der Trend der bekannten Daten auch außerhalb des bekannten Bereichs fortgesetzt wird. Diese Annahme kann falsch sein, da außerhalb des bekannten Bereichs andere Faktoren gelten könnten.
  • Unsicherheit und Ungenauigkeit: Je weiter man sich vom bekannten Datenbereich entfernt, desto größer wird die Unsicherheit. Kleine Fehler in den Daten oder bei der Modellierung können bei der Extrapolation zu großen Abweichungen führen.
  • Überanpassung (Overfitting): Besonders bei der Verwendung hochgradiger polynomialer Interpolationen kann das Modell zu sehr an die vorhandenen Datenpunkte angepasst sein, was außerhalb dieses Bereichs unzuverlässige Schätzungen liefern kann.
  • Strukturänderungen: Datenmuster können sich außerhalb des bekannten Bereichs ändern. Eine Wachstumskurve könnte z.B. stagnieren oder sich umkehren.
• Strategien zur Risikominderung:
  • Einfachere Modelle: Verwende einfache Modelle und niedrigrangige Polynome, um das Risiko der Überanpassung zu verringern.
  • Mehr Daten sammeln: Sammle mehr Daten in der Nähe des Randbereichs des bekannten Bereichs. Dadurch wird der Bereich, auf den sich die Extrapolation stützt, erweitert und Unsicherheiten werden reduziert.
  • Validierung: Nutze neue oder unabhängige Datenpunkte, um die Genauigkeit der extrapolierten Werte zu überprüfen.
  • Konfidenzintervalle: Berechne Konfidenzintervalle für die extrapolierten Werte, um die Unsicherheit der Schätzungen zu quantifizieren.
  • Domänenwissen: Nutze Fachwissen aus dem jeweiligen Gebiet, um Annahmen zu überprüfen und zu beurteilen, ob die Trends realistisch fortgesetzt werden können.
  • Alternativmethoden: Erwäge die Verwendung anderer statistischer oder maschinell lernender Methoden, die weniger anfällig für die genannten Risiken sind.

Zusammenfassend sollten bei der Extrapolation viele Vorsichtsmaßnahmen getroffen werden, um die Genauigkeit und Zuverlässigkeit der geschätzten Werte zu gewährleisten. Eine kritische Überprüfung und Validierung der Ergebnisse ist immer essentiell.

Aufgabe 2)

Optimierung von Render-PipelinesDie Optimierung der gesamten Rendering-Pipeline zielt darauf ab, die Leistung zu maximieren und Ressourcen optimal zu nutzen. Dies umfasst verschiedene Strategien wie die Verbesserung der Berechnungseffizienz, effektive Speicherverwaltung und die Verfeinerung der Render-Strategien.Im Folgenden sind einige wichtige Punkte, die bei der Optimierung einer Render-Pipeline beachtet werden sollten:

• Effizienz der Vertex- und Fragment-Shader verbessern
• Minimierung von Draw-Calls
• Culling-Techniken nutzen (z.B. Frustum Culling, Occlusion Culling)
• LOD (Level of Detail) verwenden
• State Changes und Pipeline-Stalls vermeiden
• Parallelisierung und Nutzung von Multiprocessing (z.B. GPU-Computing)
• Speichermanagement optimieren (Streaming, Texturenkompression)

a)

Erkläre, wie die Effizienz der Vertex- und Fragment-Shader verbessert werden kann. Gehe dabei auf spezifische Optimierungstechniken ein, die in modernen Grafik-APIs wie OpenGL oder Vulkan angewendet werden können.

Lösung:

Optimierung von Vertex- und Fragment-Shadern

Bei der Optimierung der Vertex- und Fragment-Shader gilt es, die Berechnungseffizienz zu maximieren und die Ausführungszeiten zu minimieren. Hier sind einige spezifische Techniken, die in modernen Grafik-APIs wie OpenGL oder Vulkan angewendet werden können:

• Vermeidung von überflüssigen Berechnungen: Wiederholte Berechnungen sollten nach Möglichkeit vermieden werden. Rechne Werte vor und speichere sie, anstatt sie mehrmals zu berechnen.
• Schleifen und Bedingungsanweisungen minimieren: Reduziere die Verwendung von Schleifen und bedingten Anweisungen innerhalb der Shader, da diese zu Leistungseinbußen führen können.
• Vektorisierung: Nutze die Vektor-Berechnungsfähigkeiten der GPU, um mehrere Operationen parallel durchzuführen. Beispielsweise können Vektor-Matrizen-Operationen genutzt werden, um mehrere Datenpunkte gleichzeitig zu berechnen.
• Effiziente Nutzung von Texturen: Texturabfragen sind oft teuer, daher sollten Texturen optimal genutzt und unnötige Abfragen vermieden werden. Textur-Cache-Effizienz kann durch ordnungsgemäße Nutzung der Texturkoordinaten und Minimierung der Anzahl der Abfragen pro Fragment verbessert werden.
• Ersetzen von If-Anweisungen durch ternäre Operatoren: Wenn möglich, ersetze If-Anweisungen durch ternäre Operatoren, um Bedingungslogik effizienter zu gestalten.
• Uniforms und Shader-Storage-Buffer-Objekte nutzen: Verwende Uniforms und Shader-Storage-Buffer-Objekte, um konsistente Daten zwischen CPU- und GPU-Speicher auszutauschen, und um Datentransfers effizienter zu gestalten.
• Shader-Aufteilung: Teile komplexe Shader in mehrere einfachere Shader auf und nutze Render-Pass-Strategien, um Teilergebnisse zu kombinieren. Dies kann dazu beitragen, die Komplexität und die IC (Instruction Count) einzelner Shader zu reduzieren.
• Voroptimierte Bibliotheken und Extensions nutzen: Grafik-APIs wie OpenGL und Vulkan bieten mehrere Extensions und voroptimierte Bibliotheken, die speziell für die Optimierung der Berechnungseffizienz entwickelt wurden. Nutze diese Ressourcen, um fortschrittliche Optimierungstechniken zu implementieren.

Durch die Anwendung dieser Techniken kannst Du die Berechnungseffizienz der Vertex- und Fragment-Shader wesentlich verbessern und damit die gesamte Rendering-Leistung erhöhen.

b)

Angenommen, Du hast eine Szene mit 10.000 individuellen Objekten, die alle gerendert werden müssen. Wie würde man die Anzahl der Draw-Calls minimieren? Beschreibe detailliert eine mögliche Strategie und die zugrunde liegenden Konzepte.

Lösung:

Minimierung von Draw-Calls für eine Szene mit 10.000 Objekten

Die Minimierung der Draw-Calls ist entscheidend für die Verbesserung der Leistung einer Render-Pipeline, insbesondere wenn eine große Anzahl von Objekten gerendert wird. Hier ist eine detaillierte Strategie zur Minimierung der Draw-Calls für eine Szene mit 10.000 individuellen Objekten:

• Instanziiertes Rendering: Eine der effektivsten Methoden zur Verringerung der Draw-Calls ist das instanzierte Rendering. Dabei wird ein Basis-Objekt einmal definiert und mehrfach instanziert. Die GPU rendert das Objekt mit unterschiedlichen Transformationen und möglicherweise unterschiedlichen Materialien, wodurch nur ein einziger Draw-Call für viele Objekte benötigt wird.
• Batching: Objekte, die das gleiche Material und die gleichen Shader verwenden, sollten gruppiert (gebatcht) werden. Batching fasst viele kleine Geometrien zu einer großen zusammen, die in einem Draw-Call gerendert werden kann. Dies reduziert die Anzahl der notwendigen Aufrufe erheblich und senkt die CPU-Belastung.
• Verwendung von Vertex-Array-Objects (VAOs) und Vertex-Buffer-Objects (VBOs): Durch die effiziente Nutzung von VAOs und VBOs kann die Anzahl der erforderlichen Draw-Calls ebenfalls reduziert werden. VAOs speichern die Zustandsinformationen von Vertex-Attributen, während VBOs die Vertex-Daten speichern. Eine korrekte Verwaltung und Nutzung dieser Objekte ermöglicht es, Sets von Geometrien effizient zu rendern.
• Level of Detail (LOD): Durch die Implementierung von LOD-Techniken wird nur eine vereinfachte Version eines Objekts gerendert, wenn dieses weit vom Betrachter entfernt ist. Dies reduziert die Anzahl und die Komplexität der zu rendernden Geometrien und kann indirekt die Anzahl der Draw-Calls verringern, da weniger detaillierte Modelle weniger Daten benötigen.
• Effizientes Culling: Culling-Techniken wie Frustum Culling, Occlusion Culling und Backface Culling helfen dabei, nicht sichtbare Objekte zu entfernen, bevor sie gerendert werden. Dies reduziert die Anzahl der Draw-Calls, da nur sichtbare Objekte verarbeitet werden müssen.
• Shader-Funktionen bündeln: Wenn Objekte ähnliche Shader-Operationen benötigen, können diese Funktionen in einer einzigen Shader-Operation gebündelt werden, um die Effizienz zu steigern und die Anzahl der separaten Draw-Calls zu reduzieren.

Zusammengefasst kann durch die Implementierung dieser Techniken die Anzahl der Draw-Calls erheblich reduziert werden. Dies führt zu einer effizienteren Nutzung der GPU und CPU, wodurch die Gesamtleistung des Renderings verbessert wird.

c)

Beschreibe die Funktionsweise von Frustum Culling und Occlusion Culling. Stelle mathematische Modelle auf, die erklären, wie festgestellt wird, ob ein Objekt durch Frustum Culling oder Occlusion Culling ausgeschlossen werden kann.

Lösung:

Funktionsweise von Frustum Culling und Occlusion Culling

Frustum Culling:

Frustum Culling ist eine Technik, mit der Objekte außerhalb des Sichtbereichs, des sogenannten View-Frustums, aus dem Render-Prozess ausgeschlossen werden. Ein View-Frustum ist im Wesentlichen ein pyramidenförmiger Bereich, der durch die Position und Ausrichtung der Kamera definiert ist und den sichtbaren Raum bestimmt. Die Funktionsweise des Frustum Culling basiert auf der mathematischen Prüfung, ob ein Objekt innerhalb dieses View-Frustums liegt.

Mathematisches Modell:

Ein View-Frustum kann als eine Kombination von sechs Ebenen dargestellt werden: linke, rechte, obere, untere, nahe und ferne Ebene.

• Gleichung einer Ebene: Jede Ebene im Raum kann durch die Gleichung \(Ax + By + Cz + D = 0\) beschrieben werden, wobei \(A, B, C\) die Normalvektoren der Ebene und \(D\) der Abstand der Ebene vom Ursprung ist.
• Prüfung, ob ein Punkt innerhalb des Frustums liegt: Ein Punkt \((x, y, z)\) liegt innerhalb des Frustums, wenn er auf der positiven Seite jeder der sechs Ebenen liegt. Dies kann durch die Überprüfung der Bedingung \(Ax + By + Cz + D > 0\) für jede Ebene erfolgen.
• Prüfung für ein ganzes Objekt: Ein Objekt wird als außerhalb des Frustums betrachtet und ausgeschlossen, wenn alle seine Vertex-Punkte auf der negativen Seite auch nur einer der sechs Ebenen liegen.

Occlusion Culling:

Occlusion Culling ist eine Technik, um Objekte auszuschließen, die von anderen Objekten verdeckt werden und daher nicht sichtbar sind. Diese Methode nutzt die Tiefeninformationen bereits gerenderter Objekte, um festzustellen, ob ein neues Objekt sichtbar ist oder nicht.

Mathematisches Modell:

Occlusion Culling basiert auf der Berechnung der Tiefenwerte (z-Werte) für jedes Pixel. Ein Objekt kann ausgeschlossen werden, wenn es vollständig von anderen Objekten verdeckt wird.

• Z-Buffer: Ein Z-Buffer speichert den kleinsten Tiefenwert für jedes Pixel. Beim Rendern eines neuen Objekts wird der Z-Wert jedes Pixels mit dem im Z-Buffer gespeicherten Wert verglichen.
• Testergebnis: Wenn der neue Z-Wert größer (weiter entfernt) ist als der gespeicherte Wert, wird das Pixel des neuen Objekts nicht gerendert, da es von einem anderen Objekt verdeckt wird.
• Hierarchical Z-Buffer (HZB): Eine optimierte Technik, die Pyramiden-Darstellungen von Tiefenwerten nutzt, um Occlusion-Tests effizienter zu gestalten. Das HZB ermöglicht es, größere Abschnitte des Bildschirms gleichzeitig auf Okklusion zu prüfen, wodurch die Renderleistung weiter verbessert wird.

Durch den Einsatz von Frustum Culling und Occlusion Culling können nicht sichtbare Objekte effizient aus der Rendering-Pipeline entfernt werden, was zu einer erheblichen Leistungssteigerung führt.

d)

Level of Detail (LOD) ist eine Technik zur Optimierung der Rendering-Leistung. Beschreibe, wie LOD implementiert wird und erkläre, welche mathematischen Methoden genutzt werden, um den geeigneten Detaillierungsgrad für ein Objekt zu bestimmen. Gehe dabei auch auf die Auswirkung auf die Performance ein.

Lösung:

Implementierung von Level of Detail (LOD)

Level of Detail (LOD) ist eine Technik zur Reduzierung der Anzahl der Berechnungen und der Detailgenauigkeit von 3D-Objekten basierend auf ihrer Entfernung zur Kamera, um die Rendering-Leistung zu optimieren. Die Idee besteht darin, hoch detaillierte Modelle nur dann zu rendern, wenn sie nah an der Kamera sind, und vereinfachte Modelle (mit weniger Polygonen) zu verwenden, wenn sie weiter entfernt sind. Hier ist, wie LOD implementiert wird und welche mathematischen Methoden dabei genutzt werden:

Implementierungsschritte:

• Vorbereitung mehrerer Modellvarianten: Für jedes Objekt werden mehrere Versionen erstellt, die sich in der Anzahl der Polygone und Details unterscheiden. Diese Varianten werden in verschiedenen LOD-Stufen (z.B. LOD0 für das detaillierteste Modell, LOD1 für eine weniger detaillierte Version usw.) gespeichert.
• Berechnung der Entfernung zur Kamera: Während des Renderings wird die Entfernung zwischen jedem Objekt und der Kamera berechnet.
• Auswahl der geeigneten LOD-Stufe: Basierend auf der berechneten Entfernung und vordefinierten Schwellenwerten wird entschieden, welche LOD-Stufe für das Rendern des Objekts verwendet wird.

Mathematische Methoden:

• Entfernungsberechnung: Die Entfernung eines Objekts zur Kamera wird als euklidische Distanz berechnet:

Die Entfernung d zwischen einem Objekt bei (x_obj, y_obj, z_obj) und der Kamera bei (x_cam, y_cam, z_cam) wird wie folgt berechnet:

d = √[(x_obj - x_cam)² + (y_obj - y_cam)² + (z_obj - z_cam)²]

• LOD-Schwellenwerte: Vordefinierte Entfernungsbereiche werden festgelegt, um zu bestimmen, welche LOD-Stufe zu verwenden ist. Zum Beispiel könnte LOD0 für Entfernungen von 0 bis 10 Einheiten, LOD1 für 10 bis 50 Einheiten und LOD2 für Entfernungen größer als 50 Einheiten verwendet werden.

Auswirkung auf die Performance:

• Rechenleistungsersparnis: Durch die Verwendung weniger detaillierter Modelle für weit entfernte Objekte wird die Anzahl der zu verarbeitenden Vertices und Fragmente reduziert, was die Berechnungslast auf der GPU verringert.
• Speicherersparnis: Da weniger detaillierte Modelle weniger Daten benötigen, kann die Speicherbandbreite effizienter genutzt werden.
• Verbesserte Framerate: Durch die Reduktion der Anzahl der Polygone und der Zeichnungsbefehle (Draw-Calls) kann die Framerate aufrecht erhalten oder verbessert werden, insbesondere in Szenen mit vielen weit entfernten Objekten.

Durch die Implementierung von LOD können erhebliche Leistungsverbesserungen erzielt werden, insbesondere in komplexen Szenen mit einer großen Anzahl von Objekten. LOD ermöglicht es, die visuelle Qualität in der Nähe des Betrachters zu erhalten, während gleichzeitig die Renderkosten für weiter entfernte Objekte reduziert werden.

Aufgabe 3)

In diesem Kontext wirst Du die grundlegenden Konzepte von Shadern und Texturen in der Computergrafik sowie deren praktische Anwendung in einem Rendering-System erforschen. Shader sind Programme, die auf der GPU ausgeführt werden und die Rendering-Pipeline beeinflussen. Es gibt verschiedene Typen von Shadern, darunter Vertex Shader, Fragment Shader und Geometry Shader. Zu den gängigen Shader-Sprachen gehören GLSL (OpenGL Shading Language) und HLSL (High-Level Shading Language). Texturen sind Bitmap-Bilder, die auf die Oberfläche von 3D-Objekten aufgetragen werden. Techniken wie UV-Mapping ermöglichen eine präzise Zuordnung von Texturkoordinaten. Mipmaps verbessern die Renderleistung durch Bereitstellung von Texturen in verschiedenen Auflösungen. Normal Mapping simuliert Oberflächendetails, um das Erscheinungsbild von Komplexität und Tiefe zu erzeugen.

a)

Du sollst ein einfaches Shader-Programm in GLSL erstellen, das eine Textur von einem Bild auf ein quadratisches 3D-Objekt anwendet. Implementiere sowohl den Vertex Shader als auch den Fragment Shader. Erkläre in Deinen eigenen Worten, wie UV-Mapping in Deinem Shader funktioniert und warum Mipmaps wichtig für die Darstellung von Texturen sind.

 'attribute vec3 aPosition; attribute vec2 aTexCoord; varying vec2 vTexCoord; void main() {     gl_Position = ... ;     vTexCoord = aTexCoord; } ' 

'precision mediump float; uniform sampler2D uTexture; varying vec2 vTexCoord; void main() {     gl_FragColor = texture2D(uTexture, vTexCoord); } ' 

Lösung:

Um ein einfaches Shader-Programm in GLSL zu erstellen, das eine Textur von einem Bild auf ein quadratisches 3D-Objekt anwendet, benötigen wir sowohl einen Vertex Shader als auch einen Fragment Shader. Der Vertex Shader berechnet die Position eines jeden Vertex und überträgt die Texturkoordinaten an den Fragment Shader, der dann die tatsächliche Farbe jedes Pixels berechnet. Hier ist eine Beispielimplementierung:

• Vertex Shader:

  'attribute vec3 aPosition; attribute vec2 aTexCoord; varying vec2 vTexCoord; void main() { gl_Position = vec4(aPosition, 1.0); vTexCoord = aTexCoord; }'

• Fragment Shader:

  'precision mediump float; uniform sampler2D uTexture; varying vec2 vTexCoord; void main() { gl_FragColor = texture2D(uTexture, vTexCoord); }'

Erklärung:

• UV-Mapping: UV-Mapping ist eine Technik, bei der 2D-Texturkoordinaten (UV-Koordinaten) den Vertices eines 3D-Objekts zugeordnet werden. In unserem Vertex Shader wird die Texturkoordinate (aTexCoord) an jedes Vertex angehängt und über die Variable vTexCoord an den Fragment Shader gesendet. Der Fragment Shader verwendet diese UV-Koordinaten, um die entsprechende Texel (Texturpixel) aus der Textur zu lesen und auf das 3D-Objekt zu projizieren.
• Mipmaps: Mipmaps sind vorkalkulierte, optimierte Texturkarten in verschiedenen Auflösungen. Sie verbessern die Renderleistung und Bildqualität, insbesondere bei Texturen, die in der Ferne oder unter bestimmten Winkeln angezeigt werden. Durch die Verwendung von Mipmaps werden Aliasing-Effekte reduziert und die Darstellung von Texturen wird schärfer. Der Shader-Code aus dem Beispiel nutzt die Funktion texture2D(), die automatisch die passende Mipmap für die aktuelle Auflösung auswählt.

Zusammenfassend zeigt der obige Code, wie man eine Textur in GLSL auf ein quadratisches 3D-Objekt anwendet, wobei UV-Mapping für die genaue Zuordnung der Textur und Mipmaps für die Optimierung der Darstellung verwendet werden.

b)

Gegeben sei eine 3D-Szene, in der Normal Mapping verwendet wird, um die Details einer Oberfläche zu simulieren. Erstelle die entsprechenden Shader-Programme, um das Normal Mapping zu realisieren. Berechne den Beleuchtungsvektor und erkläre die Schritte des Prozesses. Warum bietet Normal Mapping Vorteile bei der Darstellung von komplexen Oberflächen?

 'attribute vec3 aPosition; attribute vec3 aNormal; attribute vec2 aTexCoord; attribute vec3 aTangent; attribute vec3 aBitangent; varying vec2 vTexCoord; varying mat3 tbnMatrix; void main() {     vec3 tangent = ... ;     vec3 bitangent = ... ;     vec3 normal = ... ;     tbnMatrix = mat3(tangent, bitangent, normal);     gl_Position = ... ;     vTexCoord = aTexCoord; } '

'precision mediump float; uniform sampler2D uTexture; uniform sampler2D uNormalMap; varying vec2 vTexCoord; varying mat3 tbnMatrix; void main() {     vec3 normalFromMap = texture2D(uNormalMap, vTexCoord).rgb;     normalFromMap = normalize(normalFromMap * 2.0 - 1.0);     vec3 lightDirection = ... ;     gl_FragColor = ... ; } ' 

Lösung:

Um Normal Mapping in einer 3D-Szene zu realisieren, benötigen wir sowohl einen Vertex Shader als auch einen Fragment Shader. Der Vertex Shader berechnet die Position und die TBN-Matrix (Tangent, Bitangent, Normal Matrix) für jedes Vertex. Der Fragment Shader verwendet diese Informationen, um die Normalen aus der Normal Map anzuwenden und die Beleuchtung zu berechnen.

• Vertex Shader:

  'attribute vec3 aPosition; attribute vec3 aNormal; attribute vec2 aTexCoord; attribute vec3 aTangent; attribute vec3 aBitangent; varying vec2 vTexCoord; varying mat3 tbnMatrix; void main() { vec3 tangent = normalize(aTangent); vec3 bitangent = normalize(aBitangent); vec3 normal = normalize(aNormal); tbnMatrix = mat3(tangent, bitangent, normal); gl_Position = vec4(aPosition, 1.0); vTexCoord = aTexCoord; } '

• Fragment Shader:

  'precision mediump float; uniform sampler2D uTexture; uniform sampler2D uNormalMap; uniform vec3 uLightDirection; varying vec2 vTexCoord; varying mat3 tbnMatrix; void main() { vec3 normalFromMap = texture2D(uNormalMap, vTexCoord).rgb; normalFromMap = normalize(normalFromMap * 2.0 - 1.0); vec3 normal = normalize(tbnMatrix * normalFromMap); vec3 lightDirection = normalize(uLightDirection); float diffuse = max(dot(normal, lightDirection), 0.0); vec4 textureColor = texture2D(uTexture, vTexCoord); gl_FragColor = vec4(textureColor.rgb * diffuse, textureColor.a); } '

Erklärung:

• Beleuchtungsvektor: Der Beleuchtungsvektor, in diesem Fall uLightDirection, ist der Vektor, der von der Lichtquelle ausgeht und auf die Oberfläche des 3D-Objekts zeigt. In unserem Fragment Shader wird dieser Vektor normalisiert, um die Beleuchtungsstärke korrekt zu berechnen.
• Normal Mapping Prozess:
  • Die Tangent, Bitangent und Normal werden im Vertex Shader für jedes Vertex normalisiert und die TBN-Matrix (tbnMatrix) wird gebildet.
  • Im Fragment Shader wird die Normal Map verwendet, um die Normalen in Tangent-Raum-Koordinaten zu berechnen. Diese Normalen werden normalisiert und durch die TBN-Matrix transformiert, um in den Welt-Raum zu gelangen.
  • Die Beleuchtungsstärke wird dann durch das Skalarprodukt zwischen der transformierten Normalen und der Licht-Richtung berechnet.
  • Schließlich wird die Farbe der Textur mit der berechneten Beleuchtungsstärke multipliziert, um die finalen Farben zu berechnen.
• Vorteile von Normal Mapping: Normal Mapping ermöglicht es, detaillierte Oberflächenstrukturen zu simulieren, ohne dass die Geometrie des 3D-Objekts stark erhöht werden muss. Dies spart Rechenleistung und Speicher, während gleichzeitig komplexe und realistische Oberflächen dargestellt werden können. Es ist besonders nützlich für die Darstellung von feinen Details wie Falten, Kerben und anderen Oberflächenmerkmalen, die ansonsten sehr viele Polygone erfordern würden.

Aufgabe 4)

Ray-Tracing und Path-TracingIn dieser Aufgabe geht es um die Konzepte von Ray-Tracing und Path-Tracing, welche für die Erzeugung realistischer Bilder in der Computergrafik verwendet werden. Ray-Tracing verfolgt Lichtstrahlen von der Kamera zu den Objekten in der Szene und berechnet dabei Primär- und Sekundärstrahlen. Sekundärstrahlen entstehen durch Reflexion, Reflektion und Transmission an den Oberflächen der Objekte. Path-Tracing erweitert dieses Prinzip durch die Berechnung vieler Lichtwege pro Pixel, um eine realistische globale Beleuchtung zu simulieren. Dies geschieht mithilfe der Monte-Carlo-Integration. Die Bildgleichung, welche die Berechnung der Lichtverteilung beschreibt, lautet: \[L_o(x, \vec{\omega}_o) = L_e(x, \vec{\omega}_o) + \int_{H^2} f_r(x, \vec{\omega}_i, \vec{\omega}_o) \, L_i(x, \vec{\omega}_i) \, (\vec{\omega}_i \cdot \vec{n}) \, d\vec{\omega}_i\]

a)

1. Erkläre den Unterschied zwischen Ray-Tracing und Path-Tracing. Gehe dabei auf das Konzept von Primär- und Sekundärstrahlen sowie die Monte-Carlo-Integration ein.

Lösung:

• Ray-Tracing:Ray-Tracing ist eine Methode in der Computergrafik, bei der Lichtstrahlen von der Kamera aus durch die Szene verfolgt werden. Dabei werden Primär- und Sekundärstrahlen unterschieden.
  • Primärstrahlen: Diese Strahlen verlaufen direkt von der Kamera zu den Objekten in der Szene. Sie bestimmen die sichtbare Geometrie und die ersten Interaktionen mit den Oberflächen.
  • Sekundärstrahlen: Diese Strahlen entstehen durch Reflexion, Reflektion und Transmission (Durchdringung) an den Oberflächen der Objekte, die von den Primärstrahlen getroffen wurden. Sekundärstrahlen sind entscheidend, um Spiegelungen, Transparenzen und Lichtbrechungen zu berechnen.
• Path-Tracing:Path-Tracing ist eine Erweiterung des Ray-Tracing und simuliert eine realistische globale Beleuchtung, indem es viele Lichtwege pro Pixel unterscheidet, was zu einer besseren Lichtverteilung führt. Dies geschieht durch die Nutzung der Monte-Carlo-Integration.
  • Monte-Carlo-Integration: Diese Methode verwendet zufällige Probenpunkte, um integrale Berechnungen durchzuführen. Damit wird bei der Simulation der Lichtwege die natürliche Variation der Lichtverteilung berücksichtigt. Die resultierende Bildqualität ist realistischer, allerdings auch rechenintensiver.

b)

2. Gegeben sei eine Szene mit einer punktförmigen Lichtquelle und einer diffusen Oberfläche. Berechne die Intensität des von der Kamera empfangenen Lichts unter der Annahme, dass nur direkte Beleuchtung (Primärstrahl) berücksichtigt wird. Du darfst beliebige geeignete Annahmen machen, aber diese klar benennen. Verwende die Bildgleichung für deine Berechnung: \[L_o(x, \vec{\omega}_o) = L_e(x, \vec{\omega}_o) + \int_{H^2} f_r(x, \vec{\omega}_i, \vec{\omega}_o) \, L_i(x, \vec{\omega}_i) \, (\vec{\omega}_i \cdot \vec{n}) \, d\vec{\omega}_i\] Beschreibe jeden Schritt deiner Berechnung und erkläre die Bedeutung der verwendeten Variablen.

Lösung:

• Gegeben: Eine Szene mit einer punktförmigen Lichtquelle und einer diffusen Oberfläche. Es wird nur direkte Beleuchtung (Primärstrahl) berücksichtigt.
• Annäherungen und Annahmen:
  • Die Lichtquelle ist punktförmig und strahlt Licht in alle Richtungen gleichmäßig aus.
  • Die Oberfläche ist diffus, d.h., sie reflektiert das Licht gleichmäßig in alle Richtungen (Lambert’sches Gesetz).
  • Die Oberfläche emittiert kein eigenes Licht, d.h. \(L_e(x, \vec{\omega}_o) = 0\).
  • Die Szene enthält keine anderen Lichtquellen oder reflektierenden Oberflächen.
• Bildgleichung:Die Bildgleichung beschreibt die Lichtverteilung und lautet: \[L_o(x, \vec{\omega}_o) = L_e(x, \vec{\omega}_o) + \int_{H^2} f_r(x, \vec{\omega}_i, \vec{\omega}_o) L_i(x, \vec{\omega}_i) (\vec{\omega}_i \cdot \vec{n}) d\vec{\omega}_i\]
• Erklärung der Variablen:
  • \(L_o(x, \vec{\omega}_o)\): Ausgangsstrahlung an Punkt \(x\) in Richtung \(\vec{\omega}_o\).
  • \(L_e(x, \vec{\omega}_o)\): Emittiertes Licht der Oberfläche, in der Regel 0 für nicht-emittierende Oberflächen.
  • \(f_r(x, \vec{\omega}_i, \vec{\omega}_o)\): Bidirektionale Reflexionsverteilungsfunktion (BRDF), beschreibt, wie das Licht an Punkt \(x\) reflektiert wird.
  • \(L_i(x, \vec{\omega}_i)\): Einfallendes Licht an Punkt \(x\) aus Richtung \(\vec{\omega}_i\).
  • \(\vec{\omega}_i \cdot \vec{n}\): Kosinus-Abhängigkeit, der Winkel zwischen dem einfallenden Licht \(\vec{\omega}_i\) und der Normale \(\vec{n}\) der Oberfläche.
• Vereinfachungen:
  • Da \(L_e(x, \vec{\omega}_o) = 0\), entfällt dieser Term aus der Gleichung, da die Oberfläche kein Licht emittiert.
  • Für eine ideale diffuse Reflexion ist die BRDF konstant und beträgt \(f_r(x, \vec{\omega}_i, \vec{\omega}_o) = \frac{1}{\pi}\).
  • Das einfallende Licht von der punktförmigen Lichtquelle hat eine Intensität \(L_i(x, \vec{\omega}_i) = I_{light}\), wobei \(I_{light}\) die Intensität der Lichtquelle ist.
  • Die Normale der Oberfläche \(\vec{n}\) und das einfallende Licht \(\vec{\omega}_i\) sind parallel, daher ist \(\vec{\omega}_i \cdot \vec{n} = 1\).
• Berechnung:
  • Da die Oberfläche homogen diffus ist, und wir nur direkte Beleuchtung berücksichtigen, entfällt das Integral und wir verwenden die vereinfachte Form der Bildgleichung.
  • Einsetzen aller Annahmen und Vereinfachungen: \[L_o(x, \vec{\omega}_o) = 0 + \frac{1}{\pi} I_{light} \cdot 1 = \frac{I_{light}}{\pi}\]
• Ergebnis:Unter der Annahme einer punktförmigen Lichtquelle und einer diffusen Oberfläche sowie der Berücksichtigung nur direkter Beleuchtung, empfängt die Kamera eine Intensität von\[L_o(x, \vec{\omega}_o) = \frac{I_{light}}{\pi}\]