Computer Graphics - Exam

Aufgabe 1)

Stellen Dir vor, Du arbeitest in einem 3D-Grafikprojekt, dessen Ziel es ist, ein 3D-Modell eines Objekts mitsamt diverser Transformationen sowie der korrekten Darstellung im Rahmen verschiedener Kameramodelle zu verwirklichen. Das Modell befindet sich zunächst im Ursprung des kartesischen Koordinatensystems. Nun sollen verschiedene Transformationen durchgeführt und das Objekt aus unterschiedlichen Kameraperspektiven betrachtet werden.

a)

a) Gegeben sei ein Punkt P(1, 2, 3) im dreidimensionalen Raum. Führe die folgenden Transformationen auf diesen Punkt durch und gib die resultierenden Koordinaten an:

• Translation um den Vektor T(4, -2, 1)
• Rotation um die z-Achse um 90 Grad (im Uhrzeigersinn)
• Skalierung um den Faktor 2 in allen Achsenrichtungen

Lösung:

Um die Transformationen auf den Punkt P(1, 2, 3) durchzuführen, müssen wir die Schritte nacheinander ausführen:

• Translation: Verschiebe den Punkt um den Vektor T(4, -2, 1).
• Rotation: Rotiere den Punkt um die z-Achse um 90 Grad im Uhrzeigersinn.
• Skalierung: Skaliere den Punkt mit einem Faktor von 2 in allen Achsenrichtungen.

Wir beginnen mit der Translation:

• Translation:

Die Translation wird durch die Gleichung beschrieben:

\(x' = x + T_x\)

\(y' = y + T_y\)

\(z' = z + T_z\)

Für unseren Punkt P(1, 2, 3) und den Vektor T(4, -2, 1) bedeutet dies:

\(x' = 1 + 4 = 5\)

\(y' = 2 - 2 = 0\)

\(z' = 3 + 1 = 4\)

Der Punkt nach der Translation ist also \(P_1(5, 0, 4)\).

• Rotation um die z-Achse:

Die Rotationsmatrix für eine Rotation um die z-Achse um 90 Grad im Uhrzeigersinn lautet:

\[R_{z,-90^\circ} = \begin{bmatrix} 0 & 1 & 0 \ -1 & 0 & 0 \ 0 & 0 & 1 \end{bmatrix}\]

Die neuen Koordinaten \((x'', y'', z'')\) nach der Rotation ergeben sich durch Matrixmultiplikation:

\[\begin{bmatrix} x'' \ y'' \ z'' \end{bmatrix} = \begin{bmatrix} 0 & 1 & 0 \ -1 & 0 & 0 \ 0 & 0 & 1 \end{bmatrix} \begin{bmatrix} 5 \ 0 \ 4 \end{bmatrix} = \begin{bmatrix} 0 \ -5 \ 4 \end{bmatrix}\]

Der Punkt nach der Rotation ist also \(P_2(0, -5, 4)\).

• Skalierung:

Die Skalierungsmatrix lautet:

\[S = \begin{bmatrix} 2 & 0 & 0 \ 0 & 2 & 0 \ 0 & 0 & 2 \end{bmatrix}\]

Die neuen Koordinaten \((x''', y''', z''')\) nach der Skalierung ergeben sich durch Matrixmultiplikation:

\[\begin{bmatrix} x''' \ y''' \ z''' \end{bmatrix} = \begin{bmatrix} 2 & 0 & 0 \ 0 & 2 & 0 \ 0 & 0 & 2 \end{bmatrix} \begin{bmatrix} 0 \ -5 \ 4 \end{bmatrix} = \begin{bmatrix} 0 \ -10 \ 8 \end{bmatrix}\]

Der Punkt nach der Skalierung ist also \(P_3(0, -10, 8)\).

Zusammenfassend haben die Transformationen den Punkt \(P(1, 2, 3)\) in den Punkt \(P_3(0, -10, 8)\) überführt.

b)

b) Betrachte das Kameramodell mit einer Perspektivprojektion. Die View-Matrix ist einheitlich und die Projektions-Matrix hat die Standardparameter (Near=1, Far=100, Field of View=90°, Aspect Ratio=1). Berechne die Bildkoordinaten des transformierten Punktes aus Teil a) unter Annahme eines Projektionszentrums in der z-Achse bei (0, 0, 10). Zeichne die schrittweise umgeformten Matrizen und Herleitungen nach und gebe den finalen Punkt an.

Lösung:

Um die Bildkoordinaten des transformierten Punktes aus Teil a) mit einer Perspektivprojektion zu berechnen, benötigen wir die Transformationen und die Perspective Projection Matrix. Hier sind die Schritte dafür:

• Verwendung der View-Matrix (die in diesem Fall die Identitätsmatrix ist).
• Anwendung der Perspektivprojektion.
• Normierung der homogenen Koordinaten, um die Bildkoordinaten zu erhalten.

Gegebenen Parameter für die Perspektivprojektionsmatrix:

• Near Plane = 1
• Far Plane = 100
• Field of View (FOV) = 90°
• Aspect Ratio = 1

Für eine Perspektivprojektion lautet die Projektionsmatrix (mit FOV in Radiant):

\[ P = \begin{bmatrix} \frac{1}{\text{Aspect Ratio} \tan(\frac{\text{FOV}}{2})} & 0 & 0 & 0 \ 0 & \frac{1}{\tan(\frac{\text{FOV}}{2})} & 0 & 0 \ 0 & 0 & -\frac{\text{Far} + \text{Near}}{\text{Far} - \text{Near}} & -\frac{2 \cdot \text{Far} \cdot \text{Near}}{\text{Far} - \text{Near}} \ 0 & 0 & -1 & 0 \end{bmatrix} \]

Mit den gegebenen Werten:

FOV: 90° = π/2 (also \(\tan(π/4) = 1\))

Aspect Ratio: 1

Near Plane: 1

Far Plane: 100

wird die Projektionsmatrix so vereinfacht:

\[ P = \begin{bmatrix} 1 & 0 & 0 & 0 \ 0 & 1 & 0 & 0 \ 0 & 0 & -\frac{101}{99} & -\frac{200}{99} \ 0 & 0 & -1 & 0 \end{bmatrix} \]

Der transformierte Punkt aus Teil a) ist \( P_3(0, -10, 8) \).

Um diesen Punkt perspektivisch zu projizieren, müssen wir ihn relativ zum Projektionszentrum (0, 0, 10) transformieren. Das bedeutet, wir verschieben den Punkt um \( (0, 0, -10) \):

\(P_3'(0 - 0, -10 - 0, 8 - 10) = (0, -10, -2) \).

Nun wenden wir die Projektionsmatrix auf \(P_3'(0, -10, -2)\) an. Der Punkt wird in homogenen Koordinaten dargestellt:

\(P_3' = \begin{bmatrix} 0 \ -10 \ -2 \ 1 \end{bmatrix} \).

Multiplizieren wir die Projektionsmatrix mit diesem Punkt:

\[ P \begin{bmatrix} 0 \ -10 \ -2 \ 1 \end{bmatrix} = \begin{bmatrix} 1 & 0 & 0 & 0 \ 0 & 1 & 0 & 0 \ 0 & 0 & -\frac{101}{99} & -\frac{200}{99} \ 0 & 0 & -1 & 0 \end{bmatrix} \begin{bmatrix} 0 \ -10 \ -2 \ 1 \end{bmatrix} = \begin{bmatrix} 0 \ -10 \ 0.04 \ 2 \end{bmatrix} \]

Der resultierende Punkt in homogenen Koordinaten lautet dann:

\[ \begin{bmatrix} x_{proj} \ y_{proj} \ w_{proj} \end{bmatrix} = \begin{bmatrix} 0 \ -10 \ 0.04 \ 2 \end{bmatrix} \]

Nun teilen wir die homogenen Koordinaten durch den Skalierungsfaktor \(w_{proj}\), um die normierten Gerätikoordinaten zu erhalten:

\[ \begin{bmatrix} x_{ndc} \ y_{ndc} \ z_{ndc} \ 1 \end{bmatrix} = \begin{bmatrix} \frac{0}{2} \ \frac{-10}{2} \ \frac{0.04}{2} \ \frac{2}{2} \end{bmatrix} = \begin{bmatrix} 0 \ -5 \ 0.02 \ 1 \end{bmatrix} \]

Die endgültigen normierten Bildschirmkoordinaten des transformierten Punktes sind also:

Bildschirmkoordinaten: \( (0, -5, 0.02) \)

Aufgabe 2)

Vergleiche und Kontraste Raytracing und Rasterisierung:Raytracing ist eine Bildberechnungstechnik, bei der die Lichtpfade modelliert werden, um Reflexion, Brechung und Schatten zu berechnen, und somit eine realistische Darstellung zu erzielen, was jedoch eine hohe Rechenleistung erfordert. Ein Lichtstrahl wird dabei von der Kamera zur Lichtquelle verfolgt und der Strahlenparameter mittels der Gleichung \( \mathbf{P}(t) = \mathbf{O} + t \cdot \mathbf{D} \) bestimmt. Im Gegensatz dazu zerlegt die Rasterisierung die Szene in Dreiecke und Pixel, um das Bild darzustellen. Diese Methode ist schneller, aber weniger realistisch in der Lichtberechnung, und nutzt eine Pipeline bestehend aus den Stufen Vertex-Transformation, Rasterisierung und Fragment-Shading. Eine wichtige Gleichung in der Rasterisierung ist die Perspektivprojektion: \[ x' = \frac{x}{z}, \; y' = \frac{y}{z} \].

a)

Teilaufgabe 1:Gegeben sei ein Strahlparameter mit dem Ursprung \( \mathbf{O} = (0, 0, 0) \) und der Richtung \( \mathbf{D} = (1, 2, 3) \). Berechne die Position des Punktes entlang des Strahls für \( t = 5 \). Präzisiere die einzelnen Rechenschritte.

Lösung:

• Teilaufgabe 1:

  Gegeben sind der Ursprung des Strahls \( \mathbf{O} = (0, 0, 0) \) und die Richtung des Strahls \( \mathbf{D} = (1, 2, 3) \). Der Parameter \( t \) hat den Wert \( t = 5 \).

  Die Position des Punktes entlang des Strahls kann mit der Gleichung:

  \[ \mathbf{P}(t) = \mathbf{O} + t \cdot \mathbf{D} \]

berechnet werden. Setze die gegebenen Werte in die Gleichung ein:

\( \mathbf{P}(t = 5) = (0, 0, 0) + 5 \cdot (1, 2, 3) \)

\( 5 \cdot (1, 2, 3) = (5 \cdot 1, 5 \cdot 2, 5 \cdot 3) = (5, 10, 15) \)

 \( (0, 0, 0) + (5, 10, 15) = (0+5, 0+10, 0+15) = (5, 10, 15) \)

Daher ist die Position des Punktes entlang des Strahls für \( t = 5 \):

• \( \mathbf{P}(5) = (5, 10, 15) \)

b)

Teilaufgabe 2:Erkläre die Hauptunterschiede zwischen Raytracing und Rasterisierung in Bezug auf die Bildqualität und die benötigte Rechenleistung. Welche Vor- und Nachteile ergeben sich daraus in Bezug auf Echtzeitanwendungen wie Videospiele im Vergleich zu vorgerenderten Szenen in Filmen?

Lösung:

• Teilaufgabe 2:

  Raytracing und Rasterisierung sind zwei unterschiedliche Techniken zur Bildberechnung. Hier sind die Hauptunterschiede in Bezug auf die Bildqualität und die benötigte Rechenleistung sowie deren Vor- und Nachteile in Echtzeitanwendungen und vorgerenderten Szenen:

• Raytracing:
  • Bildqualität:

    Raytracing ermöglicht eine sehr realistische Darstellung, da es die Lichtpfade simuliert und dabei Reflexionen, Brechungen und Schatten genau berechnet. Diese Methode kann komplexe Lichteffekte wie Spiegelungen und transparente Objekte naturgetreu darstellen.

  • Rechenleistung:

    Die Berechnung der Lichtpfade erfordert eine hohe Rechenleistung, da jeder Lichtstrahl einzeln verfolgt und seine Interaktionen mit den Objekten in der Szene berechnet werden müssen. Dies führt zu längeren Berechnungszeiten.

  • Vor- und Nachteile:
    • Vorteile:

      Raytracing bietet eine überlegene Bildqualität und ermöglicht die Darstellung von realistischen Lichteffekten. Es eignet sich hervorragend für vorgerenderte Szenen in Filmen.

    • Nachteile:

      Die hohe Rechenleistung macht Raytracing weniger geeignet für Echtzeitanwendungen wie Videospiele, obwohl moderne Hardware und Algorithmen Fortschritte machen, um es auch hier nutzbar zu machen.

• Rasterisierung:
  • Bildqualität:

    Rasterisierung bietet eine schnellere Methode zur Bildberechnung, indem die Szene in Dreiecke und Pixel zerlegt wird. Die Darstellung ist weniger realistisch in Bezug auf komplexe Lichteffekte wie Reflexionen und Brechungen. Schatten können durch zusätzliche Techniken wie Shadow Mapping dargestellt werden.

  • Rechenleistung:

    Rasterisierung ist viel schneller als Raytracing und erfordert weniger Rechenleistung, wodurch sie sich gut für Echtzeitanwendungen wie Videospiele eignet. Die Grafikpipeline besteht aus mehreren Phasen (Vertex-Transformation, Rasterisierung, Fragment-Shading), die parallel und effizient auf moderner Hardware ausgeführt werden können.

  • Vor- und Nachteile:
    • Vorteile:

      Rasterisierung ist ideal für Echtzeitanwendungen, da sie eine schnelle Bildberechnung ermöglicht. Sie ist die dominierende Technologie in Videospielen und interaktiven Anwendungen.

    • Nachteile:

      Die Bildqualität ist im Vergleich zu Raytracing weniger realistisch, besonders in Bezug auf komplexe Lichteffekte. Zusätzliche Techniken sind erforderlich, um ein realistischeres Bild zu erzeugen, was die Implementierung komplizierter machen kann.

Zusammengefasst bietet Raytracing eine höhere Bildqualität auf Kosten der Rechenleistung, während Rasterisierung schnellere Berechnungen ermöglicht, aber weniger realistische Bilder erzeugt. Für Echtzeitanwendungen wie Videospiele ist Rasterisierung aufgrund der schnelleren Berechnungszeiten besser geeignet, während Raytracing sich für vorgerenderte Szenen eignet, bei denen Qualität wichtiger als Rechenleistung ist.

Aufgabe 3)

Ein virtueller 3D-Weltraum wird modelliert, in dem ein Satellit durch verschiedene Transformationen bewegt und dann auf eine 2D-Ansichtsfläche projiziert wird. Der Satellit wird zuerst um den Ursprung um 45 Grad um die Z-Achse gedreht, dann um 5 Einheiten entlang der X-Achse und schließlich um 2 Einheiten entlang der Y-Achse verschoben. Verwende homogene Koordinaten zur Darstellung der Transformationen und die entsprechende 4x4-Transformationsmatrix. Danach wird der transformierte Satellit auf eine 2D-Ansichtsfläche mittels einer perspektivischen Projektion projiziert. Das Sichtvolumen dabei ist definiert durch ein Frustum mit einem vertikalen Sichtfeld von 90 Grad, einem Seitenverhältnis von 16:9, einer Nahsichtgrenze bei 1 Einheit und einer Fernsichtgrenze bei 100 Einheiten.

a)

Bestimme die Transformationsmatrix, die die beschriebene Rotation und Translation des Satelliten kombiniert. Stelle die Resultierende in homogenen Koordinaten dar.

Lösung:

Um die Transformationsmatrix zu bestimmen, die die Rotation und Translation des Satelliten kombiniert, folgen wir diesen Schritten:

• Der erste Schritt ist die Rotation um die Z-Achse um 45 Grad.
• Der zweite Schritt ist die Translation um 5 Einheiten entlang der X-Achse.
• Der dritte Schritt ist die Translation um 2 Einheiten entlang der Y-Achse.

Wir verwenden homogene Koordinaten und die entsprechenden 4x4-Transformationsmatrizen:

1. Rotation um die Z-Achse um 45 Grad:

Die Rotationsmatrix um die Z-Achse um den Winkel \( \theta = 45^\textdegree \) ist:

\[ \begin{bmatrix} \cos(45^\textdegree) & -\sin(45^\textdegree) & 0 & 0 \ \sin(45^\textdegree) & \cos(45^\textdegree) & 0 & 0 \ 0 & 0 & 1 & 0 \ 0 & 0 & 0 & 1 \end{bmatrix} \]

Ersetzt man \( \cos(45^\textdegree) \) und \( \sin(45^\textdegree) \) durch ihre Werte, ergibt sich:

\[ \begin{bmatrix} \frac{\sqrt{2}}{2} & -\frac{\sqrt{2}}{2} & 0 & 0 \ \frac{\sqrt{2}}{2} & \frac{\sqrt{2}}{2} & 0 & 0 \ 0 & 0 & 1 & 0 \ 0 & 0 & 0 & 1 \end{bmatrix} \]

2. Translation um 5 Einheiten entlang der X-Achse:

Die Translationsmatrix für eine Verschiebung um 5 Einheiten entlang der X-Achse ist:

\[ \begin{bmatrix} 1 & 0 & 0 & 5 \ 0 & 1 & 0 & 0 \ 0 & 0 & 1 & 0 \ 0 & 0 & 0 & 1 \end{bmatrix} \]

3. Translation um 2 Einheiten entlang der Y-Achse:

Die Translationsmatrix für eine Verschiebung um 2 Einheiten entlang der Y-Achse ist:

\[ \begin{bmatrix} 1 & 0 & 0 & 0 \ 0 & 1 & 0 & 2 \ 0 & 0 & 1 & 0 \ 0 & 0 & 0 & 1 \end{bmatrix} \]

Kombinierte Transformationsmatrix:

Wir multiplizieren die Matrizen in der Reihenfolge, in der die Transformationen stattfinden:

\[ \begin{bmatrix} 1 & 0 & 0 & 0 \ 0 & 1 & 0 & 2 \ 0 & 0 & 1 & 0 \ 0 & 0 & 0 & 1 \end{bmatrix} \times \begin{bmatrix} 1 & 0 & 0 & 5 \ 0 & 1 & 0 & 0 \ 0 & 0 & 1 & 0 \ 0 & 0 & 0 & 1 \end{bmatrix} \times \begin{bmatrix} \frac{\sqrt{2}}{2} & -\frac{\sqrt{2}}{2} & 0 & 0 \ \frac{\sqrt{2}}{2} & \frac{\sqrt{2}}{2} & 0 & 0 \ 0 & 0 & 1 & 0 \ 0 & 0 & 0 & 1 \end{bmatrix} \]

Das ergibt die endgültige Transformationsmatrix:

\[ \begin{bmatrix} \frac{\sqrt{2}}{2} & -\frac{\sqrt{2}}{2} & 0 & 3.535 \ \frac{\sqrt{2}}{2} & \frac{\sqrt{2}}{2} & 0 & 4.949 \ 0 & 0 & 1 & 0 \ 0 & 0 & 0 & 1 \end{bmatrix} \]

c)

Zeige die endgültigen 2D-Koordinaten des Satelliten auf der 2D-Ansichtsfläche. Beschreibe den Prozess der Normalisierung der homogenen Koordinaten, um zu den 2D-Koordinaten zu gelangen.

Lösung:

Um die endgültigen 2D-Koordinaten des Satelliten auf der 2D-Ansichtsfläche zu zeigen, folgen wir diesem Prozess:

• Berechnung der Perspective-Projection-Matrix (Perspektivprojektionsmatrix) für das beschriebene Sichtvolumen.
• Berechnung der transformierten Koordinaten des Satelliten nach Anwendung zuvor gegebener Transformationsmatrix.
• Anwendung der Perspective-Projection-Matrix auf die transformierten Koordinaten.
• Normalisierung der homogenen Koordinaten, um zu den 2D-Koordinaten zu gelangen.

1. Berechnung der Perspektivprojektionsmatrix:

Das Sichtvolumen ist definiert durch:

• Ein vertikales Sichtfeld (FOV) von 90 Grad.
• Ein Seitenverhältnis (Ratio) von 16:9.
• Eine Nahsichtgrenze (Near) bei 1 Einheit.
• Eine Fernsichtgrenze (Far) bei 100 Einheiten.

Die Perspektivprojektionsmatrix wird durch die folgenden Parameter beschrieben:

• \( \text{fov} = \text{FOV} \)
• \( \text{ratio} = \text{Aspect Ratio} \)
• \( \text{near} = \text{Near Plane} \)
• \( \text{far} = \text{Far Plane} \)

Die Perspective-Projection-Matrix ist dann:

\[ \begin{bmatrix} \frac{1}{\text{ratio} \tan\left(\frac{ \text{FOV}}{2} \right)} & 0 & 0 & 0 \ 0 & \frac{1}{ \tan\left(\frac{ \text{FOV}}{2} \right)} & 0 & 0 \ 0 & 0 & -\frac{\text{far} + \text{near}}{\text{far} - \text{near}} & -\frac{2 \text{far} \text{near}}{\text{far} - \text{near}} \ 0 & 0 & -1 & 0 \end{bmatrix} \]

Ersetzen wir die gegebenen Werte:

• \( \text{FOV} = 90\textdegree \)
• \( \text{ratio} = \frac{16}{9} \)
• \( \text{near} = 1 \)
• \( \text{far} = 100 \)

Wir wissen, dass:

\[ \tan\left(\frac{90°}{2}\right) = 1 \]

Die resultierende Perspektivprojektionsmatrix ist daher:

\[ \begin{bmatrix} \frac{9}{16} & 0 & 0 & 0 \ 0 & 1 & 0 & 0 \ 0 & 0 & -\frac{101}{99} & -\frac{200}{99} \ 0 & 0 & -1 & 0 \end{bmatrix} \]

2. Berechnung der transformierten Koordinaten:

Die transformierte Position des Satelliten, wie angenommen nach Rotation und Translation, hat folgende Matrixform:

\[ \begin{bmatrix} \frac{\sqrt{2}}{2} & -\frac{\sqrt{2}}{2} & 0 & 5 \ \frac{\sqrt{2}}{2} & \frac{\sqrt{2}}{2} & 0 & 2 \ 0 & 0 & 1 & 0 \ 0 & 0 & 0 & 1 \end{bmatrix} \]

3. Anwendung der Perspektivprojektionsmatrix:

Multiplikation der Perspektivprojektionsmatrix mit der Transformationsmatrix:

\[ \begin{bmatrix} \frac{9}{16} & 0 & 0 & 0 \ 0 & 1 & 0 & 0 \ 0 & 0 & -\frac{101}{99} & -\frac{200}{99} \ 0 & 0 & -1 & 0 \end{bmatrix} \times \begin{bmatrix} \frac{\sqrt{2}}{2} & -\frac{\sqrt{2}}{2} & 0 & 5 \ \frac{\sqrt{2}}{2} & \frac{\sqrt{2}}{2} & 0 & 2 \ 0 & 0 & 1 & 0 \ 0 & 0 & 0 & 1 \end{bmatrix} \]

Das ergibt:

\[ \begin{bmatrix} \frac{9}{16} \times \frac{\sqrt{2}}{2} & -\frac{9}{16} \times \frac{\sqrt{2}}{2} & 0 & \frac{9}{16} \times 5 \ \frac{\sqrt{2}}{2} & \frac{\sqrt{2}}{2} & 0 & 2 \ 0 & 0 & -\frac{101}{99} & -200/99 \ 0 & 0 & -1 & 0 \end{bmatrix} \]

4. Normalisierung der homogenen Koordinaten:

Um die homogenen Koordinaten \( (x, y, z, w) \) in 2D-Koordinaten umzuwandeln, müssen diese normiert werden, indem jede Komponente durch \( w \) geteilt wird:

 \[ x' = \frac{x}{w} \] \[ y' = \frac{y}{w} \] \[ z' = \frac{z}{w} \]

Angenommen, die transformierten homogenen Koordinaten des Satelliten sind \( [x, y, z, w] = [5.6, 2.38, -3.02, w] \). Wir erhalten die endgültigen 2D-Koordinaten nach Normalisierung als:

• \( x' = \frac{5.6}{w} \)
• \( y' = \frac{2.38}{w} \)

Dies ergibt die endgültigen projizierten 2D-Koordinaten des Satelliten auf der 2D-Ansichtsfläche.

Aufgabe 4)

Shader-Programmierung mit GLSL und HLSLShader sind Programme, die auf der GPU ausgeführt werden und für die Berechnung der Grafikpipeline verwendet werden. Es gibt verschiedene Typen von Shadern: Vertex-Shader, Fragment-Shader, Geometry-Shader, Tessellation-Shader und Compute-Shader. In dieser Aufgabe wirst Du GLSL (OpenGL Shading Language) und HLSL (High-Level Shading Language) kennenlernen und anwenden. Diese zwei Sprachen werden für die Programmierung von Shadern in verschiedenen APIs (GLSL für OpenGL und HLSL für DirectX) verwendet. Einfache Shader-Programme in diesen Sprachen sind wie folgt strukturiert:

• GLSL Grundsyntax:

  void main() {  // Shader Code }

• HLSL Grundsyntax:

  float4 main() : SV_Target {  // Shader Code }

mat4 modelMatrix; vec4 worldPosition = modelMatrix * localPosition;

a)

Schreibe einen einfachen Vertex-Shader in GLSL, der die Position eines Punktes transformiert. Der Shader soll eine 4x4 Transformationsmatrix (modelMatrix) als Uniform erhalten und die Position des Punktes (localPosition) als Attribut. Transformiere die Position des Punktes und übergib sie an das nächste Pipeline-Stadium.

Lösung:

• Aufgabe: Schreibe einen einfachen Vertex-Shader in GLSL, der die Position eines Punktes transformiert. Der Shader soll eine 4x4 Transformationsmatrix (modelMatrix) als Uniform erhalten und die Position des Punktes (localPosition) als Attribut. Transformiere die Position des Punktes und übergib sie an das nächste Pipeline-Stadium.

#version 330 core// Deklaration der Uniform und Attributuniform mat4 modelMatrix;in vec4 localPosition;// Hauptfunktionvoid main() {    // Transformation der lokalen Position durch die Modellmatrix    vec4 worldPosition = modelMatrix * localPosition;        // Übergabe der transformierten Position an das nächste Pipeline-Stadium    gl_Position = worldPosition;}

b)

Schreibe ein äquivalentes HLSL-Programm für den in Teil 1 geschriebenen Vertex-Shader. Stelle sicher, dass die Transformationsmatrix (modelMatrix) und die Position des Punktes (localPosition) richtig eingebunden sind und die Position korrekt transformiert wird.

Lösung:

• Aufgabe: Schreibe ein äquivalentes HLSL-Programm für den in Teil 1 geschriebenen Vertex-Shader. Stelle sicher, dass die Transformationsmatrix (modelMatrix) und die Position des Punktes (localPosition) richtig eingebunden sind und die Position korrekt transformiert wird.

// Deklaration der Uniform und Attributcbuffer ConstantBuffer : register(b0) {    matrix modelMatrix;};struct VS_INPUT {    float4 localPosition : POSITION;};struct VS_OUTPUT {    float4 position : SV_POSITION;};VS_OUTPUT main(VS_INPUT input) {    VS_OUTPUT output;    // Transformation der lokalen Position durch die Modellmatrix    output.position = mul(modelMatrix, input.localPosition);    return output;}