So programmieren Sie eine dynamisch bewegliche Kamera in OpenGL/C++ von Grund auf

Willkommen! In diesem umfassenden Tutorial führen wir Sie durch den Prozess des Erstellens einer dynamisch beweglichen Kamera in OpenGL mit C++. Anstatt uns auf vorgefertigte Bibliotheken zu verlassen, werden wir die Grundlagen verstehen und die Kamerafunktionalität von Grund auf neu aufbauen. Dies gibt Ihnen ein tiefes Verständnis dafür, wie Kameras in 3D-Grafikanwendungen funktionieren, und bietet Ihnen die Flexibilität, Ihre Kamera genau an Ihre Bedürfnisse anzupassen.

Was Sie lernen werden

In diesem Artikel werden wir folgende Aspekte behandeln:

• Grundlagen der Kamera-Modellierung im 3D-Raum.
• Implementierung von Kamerabewegungen wie Translation und Rotation.
• Verwendung von Matrix-Transformationen zur Manipulation der Kameraansicht.
• Einrichten der Projektionsmatrix für verschiedene Perspektiven.
• Realisierung von Tastatur- und Maussteuerung zur Steuerung der Kamera in Echtzeit.

Voraussetzungen

Bevor wir beginnen, stellen Sie sicher, dass Sie mit Folgendem vertraut sind:

• Grundkenntnisse in C++-Programmierung.
• Grundlegendes Verständnis von OpenGL-Konzepten wie Vertex-Arrays, Shader und Rendering-Pipeline.
• Lineare Algebra (Vektoren, Matrizen und Transformationen).

Schritt 1: Einrichten der OpenGL-Umgebung

Zuerst müssen Sie eine funktionierende OpenGL-Umgebung einrichten. Dies beinhaltet das Einbinden der notwendigen Bibliotheken (wie GLFW für Fenstererstellung und GLEW oder Glad für OpenGL-Erweiterungsverwaltung) und das Initialisieren von OpenGL. Dieser Schritt hängt stark von Ihrem Betriebssystem und Ihrer Entwicklungsumgebung ab. Viele Online-Tutorials zeigen, wie man eine grundlegende OpenGL-Anwendung einrichtet. Achten Sie darauf, dass Sie dies erledigen, bevor Sie fortfahren.

Schritt 2: Die Kameraklasse

Lassen Sie uns eine Kameraklasse erstellen, die die Kameraposition, Ausrichtung und andere Parameter kapselt.

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>

class Camera {
public:
    // Kameraattribute
    glm::vec3 Position;
    glm::vec3 Front;
    glm::vec3 Up;
    glm::vec3 Right;
    glm::vec3 WorldUp;

    // Yaw, Pitch, Roll (Gier-, Neigungs- und Rollwinkel)
    float Yaw;
    float Pitch;
    float Roll;

    // Kamerageschwindigkeit und -empfindlichkeit
    float MovementSpeed;
    float MouseSensitivity;

    // Sichtfeld (Field of View)
    float Fov;

    // Konstruktor mit Standardwerten
    Camera(glm::vec3 position = glm::vec3(0.0f, 0.0f, 0.0f),
           glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f),
           float yaw = -90.0f, float pitch = 0.0f) :
        Position(position),
        WorldUp(up),
        Yaw(yaw),
        Pitch(pitch),
        Front(glm::vec3(0.0f, 0.0f, -1.0f)),
        MovementSpeed(2.5f),
        MouseSensitivity(0.1f),
        Fov(45.0f)
    {
        updateCameraVectors();
    }

    // Gibt die View-Matrix zurück
    glm::mat4 GetViewMatrix() {
        return glm::lookAt(Position, Position + Front, Up);
    }

    // Verarbeitet Tastatureingaben
    void ProcessKeyboard(Camera_Movement direction, float deltaTime) {
        float velocity = MovementSpeed * deltaTime;
        if (direction == FORWARD)
            Position += Front * velocity;
        if (direction == BACKWARD)
            Position -= Front * velocity;
        if (direction == LEFT)
            Position -= Right * velocity;
        if (direction == RIGHT)
            Position += Right * velocity;
        // Optional: Bewegung nach oben/unten
        if (direction == UP)
            Position += Up * velocity;
        if (direction == DOWN)
            Position -= Up * velocity;
    }

    // Verarbeitet Mauseingaben
    void ProcessMouseMovement(float xoffset, float yoffset, bool constrainPitch = true) {
        xoffset *= MouseSensitivity;
        yoffset *= MouseSensitivity;

        Yaw   += xoffset;
        Pitch += yoffset;

        // Stellen Sie sicher, dass der Bildschirm nicht auf den Kopf gestellt wird
        if (constrainPitch)
        {
            if (Pitch > 89.0f)
                Pitch = 89.0f;
            if (Pitch < -89.0f)
                Pitch = -89.0f;
        }

        // Aktualisieren der Front-, Right- und Up-Vektoren mit den aktualisierten Euler-Winkeln
        updateCameraVectors();
    }

    // Verarbeitet das Mausrad, um das FOV zu vergrößern oder zu verkleinern
    void ProcessMouseScroll(float yoffset)
    {
        Fov -= (float)yoffset;
        if (Fov < 1.0f)
            Fov = 1.0f;
        if (Fov > 45.0f)
            Fov = 45.0f;
    }

private:
    // Hilfsfunktion zur Berechnung der Kamera-Front-, Right- und Up-Vektoren
    void updateCameraVectors() {
        // Berechnen Sie den neuen Front-Vektor
        glm::vec3 front;
        front.x = cos(glm::radians(Yaw)) * cos(glm::radians(Pitch));
        front.y = sin(glm::radians(Pitch));
        front.z = sin(glm::radians(Yaw)) * cos(glm::radians(Pitch));
        Front = glm::normalize(front);
        // Berechnen Sie auch den Right- und Up-Vektor
        Right = glm::normalize(glm::cross(Front, WorldUp));  // Normalisieren Sie die Vektoren, da ihre Länge aufgrund von Operationen schnell 0 werden kann
        Up    = glm::normalize(glm::cross(Right, Front));
    }
};

// Kamerabewegungsmöglichkeiten
enum Camera_Movement {
    FORWARD,
    BACKWARD,
    LEFT,
    RIGHT,
	UP,
	DOWN
};

Dieser Code verwendet die glm-Bibliothek für Vektor- und Matrixoperationen. Sie müssen sie installieren und in Ihr Projekt einbinden. Die `Camera`-Klasse speichert die Position, Ausrichtung (mit `Front`, `Up` und `Right`-Vektoren) und die Euler-Winkel (`Yaw`, `Pitch`, `Roll`). Die `GetViewMatrix()`-Funktion gibt die View-Matrix zurück, die für die Welt-zu-Ansicht-Transformation verwendet wird. Die `ProcessKeyboard()`- und `ProcessMouseMovement()`-Funktionen ermöglichen das Verschieben und Rotieren der Kamera mit Tastatur- und Mauseingaben.

Schritt 3: Initialisieren der Kamera und der Eingaben

Erstellen Sie eine Instanz der `Camera`-Klasse und richten Sie Eingabe-Callbacks (mit GLFW oder einer ähnlichen Bibliothek) ein, um Tastatur- und Mauseingaben zu verarbeiten.

Camera camera(glm::vec3(0.0f, 0.0f, 3.0f)); // Startposition der Kamera
float lastX = 800.0f / 2.0f; // Fensterbreite / 2
float lastY = 600.0f / 2.0f; // Fensterhöhe / 2
bool firstMouse = true;

//Funktion zum Verarbeiten der Mauseingabe
void mouse_callback(GLFWwindow* window, double xpos, double ypos)
{
    if (firstMouse)
    {
        lastX = xpos;
        lastY = ypos;
        firstMouse = false;
    }

    float xoffset = xpos - lastX;
    float yoffset = lastY - ypos; // Umgekehrt, da die Koordinaten im Bereich von oben nach unten liegen

    lastX = xpos;
    lastY = ypos;

    camera.ProcessMouseMovement(xoffset, yoffset);
}

//Funktion zum Verarbeiten des Mausrads
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset)
{
    camera.ProcessMouseScroll(yoffset);
}

//Funktion zum Verarbeiten der Tastatureingabe
void processInput(GLFWwindow *window, float deltaTime) {
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
        glfwSetWindowShouldClose(window, true);

    if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
        camera.ProcessKeyboard(FORWARD, deltaTime);
    if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
        camera.ProcessKeyboard(BACKWARD, deltaTime);
    if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
        camera.ProcessKeyboard(LEFT, deltaTime);
    if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
        camera.ProcessKeyboard(RIGHT, deltaTime);
	if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
		camera.ProcessKeyboard(UP, deltaTime);
	if (glfwGetKey(window, GLFW_KEY_LEFT_CONTROL) == GLFW_PRESS)
		camera.ProcessKeyboard(DOWN, deltaTime);
}

int main() {
    // Initialisieren von GLFW, Erstellen eines Fensters usw.

    glfwSetCursorPosCallback(window, mouse_callback); //Maus-Callback registrieren
    glfwSetScrollCallback(window, scroll_callback); //Scroll-Callback registrieren
    glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); //Mauszeiger erfassen

    // Render-Loop
    while (!glfwWindowShouldClose(window)) {
        // DeltaTime berechnen
        float currentFrame = glfwGetTime();
        float deltaTime = currentFrame - lastFrame;
        lastFrame = currentFrame;

        // Eingabe verarbeiten
        processInput(window, deltaTime);

        // ... Rendering-Code ...
        glm::mat4 view = camera.GetViewMatrix(); //View-Matrix abrufen

        //Shader aktivieren und View-Matrix setzen
        ourShader.use();
        ourShader.setMat4("view", view);

        // ... Andere Rendering-Befehle ...

        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    // GLFW terminieren usw.
    return 0;
}

Dieser Code-Schnipsel zeigt, wie man die Mauseingabe erfasst und sie verwendet, um die Kamera mit der `ProcessMouseMovement()`-Funktion zu rotieren. Die `processInput()`-Funktion verarbeitet Tastatureingaben und bewegt die Kamera mit der `ProcessKeyboard()`-Funktion. `glfwSetInputMode()` wird verwendet, um den Cursor zu erfassen, so dass er im Fenster bleibt. `deltaTime` wird verwendet, um eine ruckfreie Kamerabewegung unabhängig von der Framerate zu gewährleisten.

Schritt 4: Die Projektionsmatrix

Zusätzlich zur View-Matrix benötigen Sie auch eine Projektionsmatrix, um 3D-Koordinaten in 2D-Bildschirmkoordinaten zu projizieren. Die gebräuchlichste Projektion ist die Perspektivenprojektion.

glm::mat4 projection = glm::perspective(glm::radians(camera.Fov), (float)width / (float)height, 0.1f, 100.0f);

Dieser Code erstellt eine Perspektivenprojektionsmatrix mit dem Sichtfeld (FOV), dem Seitenverhältnis (Fensterbreite geteilt durch Fensterhöhe) und den Nah- und Fernebenen. Diese Matrix muss einmalig (oder immer dann, wenn sich die Fenstergröße ändert) berechnet und an Ihren Shader übergeben werden.

Schritt 5: Übergabe der Matrizen an den Shader

Übergeben Sie die View- und Projektionsmatrizen an Ihren Shader als Uniform-Variablen.

// Vertex-Shader
#version 330 core
layout (location = 0) in vec3 aPos;

uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

void main()
{
    gl_Position = projection * view * model * vec4(aPos, 1.0);
}

//In Ihrer Rendering-Schleife:
glm::mat4 model = glm::mat4(1.0f); // Modellmatrix initialisieren
//... Modell-Matrix-Transformationen hier ...
unsigned int modelLoc = glGetUniformLocation(shaderProgram, "model");
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
unsigned int viewLoc  = glGetUniformLocation(shaderProgram, "view");
glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
unsigned int projectionLoc = glGetUniformLocation(shaderProgram, "projection");
glUniformMatrix4fv(projectionLoc, 1, GL_FALSE, glm::value_ptr(projection));

Dieser Code zeigt, wie man die Modell-, View- und Projektionsmatrizen an den Vertex-Shader übergibt. Die Vertex-Position wird dann mit `projection * view * model` transformiert, um sie in den Clipping-Raum zu transformieren.

Zusammenfassung

In diesem Tutorial haben wir die Grundlagen für die Implementierung einer dynamisch beweglichen Kamera in OpenGL mit C++ behandelt. Wir haben eine `Camera`-Klasse erstellt, Kamerabewegungen implementiert, die View- und Projektionsmatrizen eingerichtet und gelernt, wie man Eingaben für Kamerasteuerung verarbeitet. Dieses Wissen bildet eine solide Grundlage für die weitere Anpassung und Erweiterung Ihrer Kamerafunktionalität.

Nächste Schritte

Hier sind einige Ideen, um Ihr Kamera-System weiter zu verbessern:

• Implementieren Sie verschiedene Kameramodi wie First-Person, Third-Person oder Orbit-Kamera.
• Fügen Sie Kollisionserkennung hinzu, um zu verhindern, dass die Kamera durch Objekte hindurchgeht.
• Implementieren Sie weiche Kamerabewegungen mit Interpolation oder Dämpfung.
• Experimentieren Sie mit verschiedenen Projektionstypen wie orthografische Projektion.

Indem Sie diese Schritte befolgen und Ihr Verständnis der Kamerafunktionalität vertiefen, können Sie atemberaubende und immersive 3D-Erlebnisse in Ihren OpenGL-Anwendungen erstellen.