OpenGL (część 2) – konfiguracja środowiska i pierwszy program

Zaczynając pracę z OpenGL-em najpierw należy stworzyć kontekst aplikacji. Następnym krokiem jest stworzenie okna, w którym będziemy generować naszą oszałamiającą grafikę. Aby osiągnąć ten pierwszy cel należy najpierw zapoznać się z pomocnymi bibliotekami. Najczęściej są stosowane takie jak: GLUT, GLFW, SDL, SFML. My będziemy korzystać z GLFW.

Biblioteka GLFW

Jest to biblioteka napisana w języku C i służy do wspomagania pracy z OpenGL, OpenGL ES (dla systemu Android) oraz Vulkan (nowa biblioteka alternatywna dla OpenGL). GLFW dostarcza programiście API (kompletu funkcji) do tworzenia okien, kontekstów, powierzchni oraz do obsługi zdarzeń. Na stronie GLFW można pobrać wersje dla Windows, macOS oraz całej rodziny systemów Unix/Linux.

Budowanie/Instalacja GLFW

W systemach Linux (ja używam Manjaro Linux) wystarczy zainstalować za pomocą menedżera pakietów bibliotekę glfw (w Manjaro Linux nazywa się glfw-x11). I to jest cała praca, jaka była do wykonania.

W systemie Windows po pobraniu archiwum można je rozpakować i pracować na plikach, jakie zawiera, ponieważ GLFW jest przystosowane do pracy z Visual Studio 2015/2017. Można także skompilować bibliotekę z kodu źródłowego. Należy oczywiście pamiętać o pobraniu odpowiednich wersji – 32-bitowej lub te 64-bitowej. Jeżeli nie masz doświadczenia z GLFW, to dla 64-bitowego Windowsa pobierz wersję 32-bitową! W przeciwnym razie możesz doświadczyć całej serii błędów. Po pobraniu i wypakowaniu archiwum interesuje nas: skompilowana biblioteka, folder include, który zawiera pliki źródłowe do kompilacji i budowy GLFW we własnym zakresie. Kompilacja biblioteki we własnym zakresie daje gwarancję, że będzie ona dostosowana do Twojego sprzętu. Będzie działać optymalnie na Twoim komputerze. Kompilacja biblioteki (każdej) może być operacją nieco kłopotliwą. Dlatego powstało narzędzie do tego celu, które nazywa się CMake.

CMake

To program służący do budowania aplikacji oraz bibliotek z kodu źródłowego. Można go używać w różnych IDE (Visual Studio, Eclipse, CLion). Ja cenię produkty firmy JetBrains, dlatego używam CLiona (jeżeli jesteś uczniem, albo studentem, to CLiona jak każdy inny produkt JetBrains możesz uzyskać bezpłatnie).

CMake pozwala na wygenerowanie bibliotek GLFW z plików zawierających kod źródłowy. Do zainstalowania Cmake można użyć instalatora win32 w przypadku systemów Windows. Pod kontrolą Linuksa wystarczy zainstalować pakiet cmake (tak się nazywa w Manjaro Linux). Po zainstalowaniu mamy do dyspozycji dwie wersje: cmake – działający w trybie tekstowym oraz cmake-gui, który ma graficzny interfejs użytkownika (GUI). Jeżeli chcesz użyć wersji z GUI, to jako folder źródłowy wybierz folder główny pobranego pakietu GLFW, a jako docelowy – nowy, utworzony przez nas katalog. Następnie należy kliknąć Configure, a po odczytaniu przez CMake danych pakietu klikamy Generate, dla wygenerowania plików docelowych biblioteki.

Biblioteka GLAD

GLAD jest biblioteką odpowiedzialną za generowanie ładowanie rozszerzeń GL/GLES/EGL/GLX/WGL i jest dostępna w ramach open source. Alternatywą dla tej biblioteki jest używanie biblioteki GLEW. Ja wybrałem GLAD. Mamy wiele wersji sterowników oraz rozszerzeń, funkcji OpenGL, GLAD tym wszystkim zarządza, aby kod aplikacji nie był zbytnio skomplikowany do napisania oraz późniejszego utrzymania. Można ją pobrać i skompilować bezpośrednio ze źródeł, albo skorzystać z narzędzia on-line.

Pierwsza aplikacja

Wreszcie dochodzimy do pierwszego programu w OpenGL. Będzie on rysować i wyświetlać okno. Na początek to wystarczy.

Najpierw musimy załączyć biblioteki, których będziemy używać w tej aplikacji oraz deklarujemy przestrzeń nazw std:

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <iostream>

using namespace std;

Biblioteka GLAD musi być zawsze dołączona przed innymi, jako pierwsza. Tutaj jest przed GLEW.

Następnie deklarujemy funkcje odpowiedzialne za zainicjowanie okna:

void framebuffer_size_callback(GLFWwindow* window, int width, int height);
void processInput(GLFWwindow *window);

Następnie ustalamy rozmiar okna:

const unsigned int SCREEN_WIDTH = 1280;
const unsigned int SCREEN_HEIGHT = 1024;

Oraz inicjujemy metodę main(), która zawierać będzie rdzeń naszej aplikacji:

int main(void){
    // inicjacja i konfiguracja
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    // utworzenie okna w GLFW
    GLFWwindow* window = glfwCreateWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "Pierwsza_aplikacja OpenGL", NULL, NULL);
    if (window == NULL){
        cout << "Nie moge stworzyc  okna w GLFW" << endl;
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

    // glad laduje wskazniki do funkcji OpenGL
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)){
        std::cout << "Failed to initialize GLAD" << std::endl;
        return -1;
    }    

    // petla renderujaca
    while (!glfwWindowShouldClose(window)){
        //wejscie
        processInput(window);

        // kolor tla
        glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        // glfw: obsluga buforow oraz zdarzen Input Ouput
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    // glfw: porzadki i czyszczenie
    glfwTerminate();
    return 0;
}

// wejscie - odpytywanie GLFW czy klawisze sa wcisniete
void processInput(GLFWwindow *window){
    if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
        glfwSetWindowShouldClose(window, true);
}

// glfw: funkcja odpowiedzialna za zmiane rozmiaru okna
void framebuffer_size_callback(GLFWwindow* window, int width, int height){
    
    glViewport(0, 0, width, height);
}
Efekt działania programu

Dodaj komentarz

Twój adres email nie zostanie opublikowany. Pola, których wypełnienie jest wymagane, są oznaczone symbolem *