Lektion 10

Dieses Tutorial wurde von Lionel Brits (ßetelgeuse) geschrieben. Diese Lektion erklärt nur die Code-Segmente, die hinzugefügt wurden. Nur durch hinzufügen der Zeilen wird das Programm nicht laufen. Wenn Sie daran interessiert sind, wo die Zeilen eingefügt werden müssen, laden Sie sich den Source Code herunter und folgen sie ihm, während Sie das Tutorial lesen.

Willkommen zum infamosen Tutorial 10. Bisher haben Sie einen rotierenden Würfel oder ein paar Sterne und Sie haben das grundlegende Gefühl für 3D Programmierung. Aber Moment! Laufen Sie nicht weg und fangen Sie nicht an Quake IV zu programmieren. Mit rotierende Würfel kann man einfach kein cooles Deathmatch machen :-) Was Sie heutzutage brauchen ist eine große komplizierte und dynamische 3D Welt mit 6 Winkeln an Freiheiten und atemraubende Effekte wie Spiegel, Portale, Warping und selbstverständlicherweise hohe Frame Raten. Dieses Tutorial erklärt die grundsätzlichen "Strukturen" einer 3D Welt und wie man sich in ihr bewegt.

Daten Struktur

Während es völlig in Ordnung ist, eine 3D Umgebung als eine lange Serie an Zahlen zu coden, wird es immer schwieriger, so bald die Komplexität der Umgebung wächst. Aus diesem Grund, müssen wir unsere Daten kategorizieren und zwar in ein einfacher zu handhabenden Weg. Am Anfang unserer Liste ist der Sektor. Jede 3D Welt basiert auf einer Ansammlung von Sektoren. Ein Sektor kann ein Raum, ein Würfel oder jedes andere geschlossene Volumen sein.

typedef struct tagSECTOR                        // erzeuge unsere Sektor-Struktur
{
    int numtriangles;                        // Anzahl der Dreiecke im Sektor
    TRIANGLE* triangle;                        // Zeiger auf ein Array aus Dreiecken
} SECTOR;                                // Nenne sie SECTOR

Ein Sektor enthält eine Reihe von Polygonen, weshalb die nächste Kategorie das Dreieck sein wird (wir bleiben bei Dreiecken zunächst, weil diese viel einfache zu programmieren sind.)

typedef struct tagTRIANGLE                        // erzeuge unsere Dreiecks-Struktur
{
    VERTEX vertex[3];                        // Array aus drei Vertices
} TRIANGLE;                                // Nenne sie TRIANGLE

Das Dreieck ist grundlegend ein Polygpn, dass aus Vertices (Plural von Vertex) besteht, welche uns zur letzten Kategorie kommen lässt. Der Vertex enthält die wirklichen Daten, in denen OpenGL interessiert ist. Wir definieren jeden Punkt eines Dreiecks mit seiner Position im 3D Raum (X, Y, Z) sowie seiner Textur-Koordinaten (u, v).

typedef struct tagVERTEX                        // erzeuge unsere Vertex Structur
{
    float x, y, z;                            // 3D Koordinaten
    float u, v;                            // Textur Koordinaten
} VERTEX;                                // Nenne sie VERTEX

Dateien laden

Unsere Welt-Daten innerhalb unseres Programms zu speichern, macht es recht statisch und langweilig. Wenn wir unsere Welt allerdings von der Platte laden, sind wir flexibler, da wir verschiedene Welten testen können, ohne unser Programm neu kompilieren zu müssen. Ein weiterer Vorteil ist, dass der Benutzer Welten austauschen und modifzieren kann, ohne das innere unseres Programms vor sich zu haben. Die Art der Daten-Datei, die wir benutzen werden, wird reiner Text sein. Das macht es leichter, die Daten zu ändern und wir benötigen weniger Code. Wir bewahren uns binäre Dateien für später auf.

Die Frage ist, wie wir unsere Daten aus unserer Datei bekommen. Als erstes erzeugen wir eine neue Funktion namens SetupWorld(). Wir definieren unsere Datei als filein und wir öffnen es für nur-lesen-Zugriffe. Wir müssen unsere Datei auch wieder schließen wenn wir fertig sind. Lassen Sie uns einen Blick auf den bisherigen Code werfen:

// Vorherige Deklaration: char* worldfile = "data\\world.txt";
void SetupWorld()                            // initialisiere unsere Welt
{
    FILE *filein;                            // Datei mit der gearbeitet werden soll
    filein = fopen(worldfile, "rt");                // öffne unsere Datei

    ...
    (lese unsere Daten)
    ...

    fclose(filein);                            // schliesse unsere Datei
    return;                                // springe zurück
}

Unsere nächste Herausforderung ist es, jede einzelne Zeile Text in eine Variable zu lesen. Das kann auf zahlreichen Wegen geschehen. Ein Problem ist, dass nicht alle Zeilen brauchbare Informationen enthalten. Leerzeilen und Kommentare sollen nicht gelesen werden. Lassen Sie uns eine Funktion names readstr() erzeugen. Diese Funktion liest eine bedeutsame Zeile Text in einen initialisierten String. Hier ist der Code:

void readstr(FILE *f,char *string)                    // lese einen String ein

{
    do                                // beginne eine Schleife
    {
        fgets(string, 255, f);                    // lese eine Zeile
    } while ((string[0] == '/') || (string[0] == '\n'));        // schaue nach, ob sie es wert ist bearbeitet zu werden
    return;                                // springe zurück
}

Als nächstes müssen wir die Sektor-Daten einlesen. Diese Lektion wird nur mit einem Sektor umgehen können, aber es ist recht einfach eine Multi-Sektor Engine zu implementieren. Kommen wir zurück zu SetupWorld(). Unser Programm muss wissen, wie viele Dreiecke sich in unserem Sektor befinden. In unserer Daten-Datei definieren wir die Anzahl der Dreiecke wie folgt:

NUMPOLLIES n

Hier ist der Code, der die Anzahl der Dreiecke liest:

int numtriangles;                            // Anzahl der Dreiecke im Sektor
char oneline[255];                            // String um Daten darin zu speichern
...
readstr(filein,oneline);                        // hole einzelne Zeile an Daten
sscanf(oneline, "NUMPOLLIES %d\n", &numtriangles);            // Lese Anzahl der Dreiecke ein

Der Rest unseres Welt-Lade-Prozesses wird den selben Prozess verwenden. Als nächstes initialisieren wir unseren Sektor und lesen einige Daten ein:

// Previous Declaration: SECTOR sector1;
char oneline[255];                            // String um Daten darin abzuspeichern
int numtriangles;                            // Anzahl der Dreiecke im Sektor
float x, y, z, u, v;                            // 3D und Textur Koordinaten
...
sector1.triangle = new TRIANGLE[numtriangles];                // Alloziiere Speicher für numtriangles und setze Pointer
sector1.numtriangles = numtriangles;                    // Definiere die Anzahl der Dreiecke in Sektor 1
// Gehe schrittweise durch jedes Dreieck im Sektor
for (int triloop = 0; triloop <numtriangles; triloop++)        // durchlaufe alle Dreiecke
{
    // durchlaufe jeden Vertex im Dreieck
    for (int vertloop = 0; vertloop <3; vertloop++)        // durchlaufe alle Vertices
    {
        readstr(filein,oneline);                // Lese String ein, mit dem gearbeitet werden soll
        // Lese Daten ein respektive Vertex Werte
        sscanf(oneline, "%f %f %f %f %f", &x, &y, &z, &u, &v);
        // Speicher Werte in den entsprechenden Vertices
        sector1.triangle[triloop].vertex[vertloop].x = x;    // Sektor 1, Dreieck triloop, Vertice vertloop, x Wert=x
        sector1.triangle[triloop].vertex[vertloop].y = y;    // Sektor 1, Dreieck triloop, Vertice vertloop, y Wert=y
        sector1.triangle[triloop].vertex[vertloop].z = z;    // Sektor 1, Dreieck triloop, Vertice vertloop, z Wert=z
        sector1.triangle[triloop].vertex[vertloop].u = u;    // Sektor 1, Dreieck triloop, Vertice vertloop, u Wert=u
        sector1.triangle[triloop].vertex[vertloop].v = v;    // Sektor 1, Dreieck triloop, Vertice vertloop, v Wert=v
    }
}

Jedes Dreieck in unserer Daten-Datei ist wie folgt deklariert:

X1 Y1 Z1 U1 V1
X2 Y2 Z2 U2 V2
X3 Y3 Z3 U3 V3