Grundlagen: Dreidimensionaler Raum repräsentieren

Bevor ein einzelnes Pixel gezeichnet wird, muss eine 3D-Engine eine mathematische Sprache haben, um Objekte im Raum zu beschreiben. Im Kern sind vektoren (dreikomponentige Tupel, die Position, Richtung oder Farbe repräsentieren) und matrizen (4 × 4 Arrays, die Transformationen codieren).

  • für Punkte und Vektoren.
  • für Transformationsmatrizen, die in der Reihenfolge der Spalten-Hauptreihen gespeichert sind.

Jedes Objekt besteht aus Dreiecken. Ein Dreieck wird durch drei Eckpunkte definiert, jeder mit einer Position und optional einer Normalen und Farbe. Diese als zusammenhängende Arrays zu speichern (z. B. für einen Würfel) verbessert die Cache-Effizienz - eine kritische Überlegung, wenn Sie später Tausende von Gesichtern pro Frame verarbeiten.

Die Grafik-Pipeline: Von den Ecken zu den Pixeln

Eine Grafik-Pipeline ist eine Abfolge von Phasen, die 3D-Szenendaten in ein 2D-Bild umwandelt. In einer grundlegenden Software-gerenderten Engine implementieren Sie jede Phase manuell.

  1. Vertex Processing – Anwendung von Modell-, Ansichts- und Projektionstransformationen.
  2. Rasterization – Umwandlung transformierter Dreiecke in Fragmente (potenzielle Pixel).
  3. Shading – Berechnung der Farbe jedes Fragments basierend auf Beleuchtung und Material.
  4. Output Merging – Mischen von Fragmenten mit dem Frame-Puffer, einschließlich Tiefentests.

Hardwarebeschleunigte Engines (mit OpenGL, Vulkan oder DirectX) führen die meisten dieser Schritte auf der GPU aus, aber das Verständnis des Softwarepfads gibt Ihnen einen tiefen Einblick in die Funktionsweise der GPU unter der Haube.

Vertex Verarbeitung und Transformationen

Jeder Scheitelpunkt beginnt in Modellraum (lokale Koordinaten relativ zum Objekt). Um es in der Welt zu positionieren, wenden Sie eine Modellmatrix an, die Übersetzung, Rotation und Skalierung codiert. Dann verwandelt die Ansichtsmatrix Weltkoordinaten in Kamera-relative Koordinaten (View Space). Schließlich bildet die Projektionsmatrix den Ansichtsraum einem normalisierten Koordinatensystem ( Clipraum zu, wo perspektivische Division und Viewport-Mapping Bildschirmkoordinaten erzeugen.

In C sehen Transformationsfunktionen wie folgt aus:

  • – gibt eine Identitätsmatrix zurück.
  • – baut eine Übersetzungsmatrix auf.
  • – Rotation um die X-Achse.
  • – multipliziert eine 4×4-Matrix mit einem 4-Elemente-Vektor (homogene Koordinaten).

Das Vertex Shader-Äquivalent in der Software iteriert über alle Vertices, multipliziert jedes mit der kombinierten Matrix und speichert das Ergebnis in einem transformierten Vertex-Puffer.

Projektion: Perspektive versus Orthographie

Die Projektion steuert, wie die Tiefe auf dem Bildschirm dargestellt wird. Perspektive Projektion lässt entfernte Objekte kleiner erscheinen und erzeugt Realismus. Seine Matrix wird aus dem Sichtfeld, dem Seitenverhältnis, den Nah- und Fernschnittebenen aufgebaut. Die klassische Formel beinhaltet die Division der x- und y-Komponenten durch z (nach der Matrixmultiplikation). In C berechnet man die Projektionsmatrix einmal und verwendet sie in jedem Frame wieder:

  • – gibt eine Standard-Perspektivmatrix zurück.

Orthographische Projektion bewahrt parallele Linien und ist einfacher, für UI- oder CAD-Tools verwendet.

Rasterisierung: Füllen von Dreiecken

Nach der Projektion haben Sie 2D-Bildschirmkoordinaten (wie Pixelpositionen) und einen Tiefenwert (z). Die Rasterisierung bricht jedes Dreieck in Fragmente, die ganzzahlige Pixelkoordinaten abdecken. Der klassische Algorithmus ist scanline-Konvertierung:

  1. Sortieren Sie die drei Eckpunkte des Dreiecks nach Y-Koordinate.
  2. Gehen Sie den linken und rechten Rand entlang und berechnen Sie x Grenzen für jede Scanline.
  3. Berechnen Sie für jedes Pixel in der horizontalen Spannweite die Tiefe des Fragments, indem Sie über das Dreieck interpolieren.
  4. Führen Sie einen Tiefentest durch: Vergleichen Sie das z des Fragments mit dem Wert, der sich bereits im Tiefenpuffer befindet.

Die effiziente Implementierung des Edge-Walking-Algorithmus in C erfordert enge Schleifen und die sorgfältige Verwendung von Fixpunktarithmetik, um Gleitkomma-Overhead zu vermeiden. Viele Hobby-Engines beginnen mit einem Brute-Force-Ansatz (Prüfung jedes Pixels im Bounding-Box) und optimieren später mit Edge-Gleichungen.

Schattierung und Beleuchtung

Ein einfacher flach schattiert Motor verwendet eine einzelne Farbe pro Dreieck, berechnet aus dem Gesicht normal und eine einzige Lichtquelle. Das Lambertian Modell gibt diffuse Intensität: In C berechnen Sie die Normale als Kreuzprodukt von zwei Dreieckskanten (nach Umwandlung Eckpunkte in Weltraum), dann multiplizieren Sie die Lichtintensität mit der Grundfarbe des Dreiecks.

Um Tiefe zu erhöhen, implementieren Sie Gouraud Shading (Vertex-Normale, interpoliert über Fragmente) oder Phong Shading (pro Pixel-Normale). Letzteres erfordert Interpolation von Weltpositionen und Normalen, dann Berechnung der Beleuchtung pro Fragment - teurer, aber dramatisch bessere Ergebnisse.

Bauen Sie den Motor in C: Praktische Schritte

Lassen Sie uns durch die Konstruktion einer minimalen Software-3D-Engine von Grund auf neu gehen. Das Ziel ist es, einen rotierenden Würfel mit Umgebungs- und diffuser Beleuchtung auf ein 640 × 480 Pixelfenster zu bringen.

Schritt 1 - Einrichten eines Pixel-Puffers

Definieren Sie einen Speicherpuffer für den Rahmen und die Tiefe: und ; löschen Sie den Framebuffer auf Schwarz und den Tiefenpuffer auf 1,0 (Fernebene) jedes Frame.

Schritt 2 – Definieren von Szenendaten

Für einen Würfel benötigen sechs Flächen (12 Dreiecke) 12 × 3 = 36 Eckpunkte. Speichern Sie sie in einem Array von Strukturen mit Position (3 Schwimmer) und Farbe (3 Schwimmer für RGB). Vordefinieren Sie die 8 einzigartigen Würfelecken und sechs Gesichtsfarben. Verwenden Sie einen Indexpuffer, um Vervielfältigungen zu vermeiden.

Schritt 3 – Transformation Pipeline

Jedes Bild berechnet die Modellmatrix aus einem Winkel (z. B. rotationY(time)), die Ansichtsmatrix einer festen Kamera, die den Ursprung betrachtet, und die Projektionsmatrix. Kombinieren Sie sie zu einer einzigen MVP-Matrix: . Transformieren Sie jeden Scheitelpunkt, indem Sie mit multiplizieren. Führen Sie dann eine perspektivische Teilung durch (teilen Sie x,y,z mit w) aus, um normalisierte Gerätekoordinaten zu erhalten (-1 bis +1). Karte auf Bildschirmkoordinaten: , (y invertiert). Behalten Sie den NDC z für Tiefentests.

Schritt 4 - Rastern und Schattieren

Wenn Sie Pixel laufen, interpolieren Sie die Tiefe und interpolieren Sie auch ein Pervertex-Attribut wie die Welt-Raum-Position (für Phong) oder die Scheitelpunktnormale (für Gouraud). Wenden Sie die Lambertsche diffuse Gleichung an. Schreiben Sie die endgültige Farbe in den Framebuffer, wenn der Tiefentest besteht.

Schritt 5 – Display

Verwenden Sie SDL (Simple DirectMedia Layer) oder eine ähnliche Bibliothek, um ein Fenster zu erstellen und den Framebuffer zu blitten, z. B. mit SDL2: , , in , dann und jedem Frame.

Dieser Softwarepfad läuft auf der CPU, so dass die Leistung auf ein paar tausend Dreiecke pro Frame beschränkt ist. Sobald Sie es bequem haben, können Sie die Rasterisierungsebene durch OpenGL ersetzen, wodurch die schwere Arbeit auf die GPU übertragen wird, während Ihre Transformations- und Szenenlogik in C bleibt.

Optimieren Sie Ihren Motor

Eine Basis-Engine ist langsam. Mehrere Optimierungen sind für die Echtzeit-Leistung unerlässlich:

  • Back-face culling: Skip Dreiecke, deren Normalen von der Kamera weg zeigen. Berechnen Sie die signierte Fläche des projizierten Dreiecks (in 2D) oder überprüfen Sie das Punktprodukt der Gesichtsnormalen mit der Blickrichtung.
  • Frustum culling: Testen Sie die Begrenzungsbox eines Objekts gegen die sechs Ebenen der Ansicht frustum.
  • Fixpunkt-Arithmetik: Ersetzen Sie Gleitkomma-Operationen durch Ganzzahl-Mathematik in engen Rasterisierungsschleifen.
  • Pre-Transformation Cache: Vermeiden Sie die Transformation der gleichen Vertex mehrmals durch die Transformation aller Eckpunkte eines Mesh einmal, dann mit Indizes.
  • Blocked Frame Buffer schreibt: Schreibe Pixel in der Speicherreihenfolge (links nach rechts, von oben nach unten), um die Cache-Hits zu maximieren.

Diese Techniken können einen Software-Renderer von 3-5 fps auf 60 fps für Szenen mit mäßiger Komplexität (z. B. einige hundert Dreiecke) verschieben.

Erweitern des Motors

Sobald eine solide Grundlage vorhanden ist, können Sie inkrementell Funktionen hinzufügen:

  • Textur-Mapping: Speichern Sie 2D-Bilder und interpolieren Sie UV-Koordinaten über Dreiecke hinweg. Implementieren Sie bilineare Filterung für reibungslose Ergebnisse.
  • Erweiterte Schattierung: Fügen Sie spiegelnde Highlights (Blinn-Phong), Umgebungsverschluss oder sogar Schattenkarten hinzu.
  • Szenenmanagement: Verwenden Sie einen Octree- oder BSP-Baum, um schnell zu bestimmen, welche Objekte sichtbar sind.
  • Benutzerinteraktion: Behandle Tastatur- und Mauseingaben, um die Kamera zu umkreisen oder Objekte auszuwählen.
  • Pipeline-Abstraktion: Entwerfen Sie ein Shader-System: Definieren Sie Vertex- und Fragmentfunktionen als Funktionszeiger, was ein flexibles Rendern ohne Rekompilierung ermöglicht.

Ressourcen und weitere Lektüre

Um Ihr Verständnis zu vertiefen, erkunden Sie die klassischen Texte und Online-Tutorials, die diese Engine inspiriert haben:

  • Scratchapixel – Tiefe Erklärungen von Raytracing, Rasterisierung und Mathematik.
  • LearnOpenGL – Moderne OpenGL Tutorials; Beginnen Sie mit dem Kapitel “Hallo Dreieck”.
  • Wikipedia: 3D Projection – Die formale Mathematik hinter Perspektive und orthografischen Matrizen.

Der Bau einer 3D-Engine in C ist ein Übergangsritus für Grafikprogrammierer. Er lehrt Sie nicht nur, wie Sie effizienten Code schreiben, sondern auch, wie Sie in drei Dimensionen denken und leistungskritische Systeme komponieren. Beginnen Sie mit einem einzigen rotierenden Würfel, fügen Sie dann weitere Dreiecke und Texturen hinzu und geben Sie sie schließlich an die GPU weiter. Die Reise vom rohen C zu einer voll funktionsfähigen Engine offenbart die Magie hinter jedem Pixel auf dem Bildschirm.