Zapoznanie się z OpenGL trzeba zacząć od tego, że OpenGL nim jest specyfikacja. Te. OpenGL po prostu definiuje zestaw wymaganych możliwości. Implementacja zależy od konkretnej platformy.
OpenGL to wieloplatformowy, niezależny od języka graficzny interfejs API. OpenGL jest interfejsem API niskiego poziomu, więc dobrym pomysłem jest ogólna znajomość grafiki i podstaw algebry liniowej, aby z nią pracować.

Nazewnictwo

Powiedzmy kilka słów o nazewnictwie funkcji w OpenGL. Po pierwsze, nazwy wszystkich funkcji udostępnianych bezpośrednio przez OpenGL zaczynają się od przedrostka gl. Po drugie, funkcje określające określony parametr charakteryzujący się zbiorem liczb (na przykład współrzędną lub kolorem) mają przyrostek w postaci [liczba parametrów + typ parametrów + reprezentacja parametrów].

• Liczba parametrów - wskazuje liczbę zaakceptowanych parametrów. Akceptuje następujące wartości: 1 , 2 , 3 , 4
• Typ parametru - wskazuje typ akceptowanych parametrów. Możliwe są następujące wartości: B, S, I, F, D, ub, nas, interfejs użytkownika. Te. bajt (znak w C, 8-bitowa liczba całkowita), short (16-bitowa liczba całkowita), int (32-bitowa liczba całkowita), float (liczba zmiennoprzecinkowa), double (liczba zmiennoprzecinkowa podwójnej precyzji), bajt bez znaku, krótki znak bez znaku, unsigned int (ostatnie trzy to liczby całkowite bez znaku)
• Reprezentacja parametrów - wskazuje w jakiej formie są przekazywane parametry; jeżeli każda liczba jest indywidualna to nic nie jest zapisywane; jeśli parametry są przekazywane w formie tablicy to do nazwy funkcji dodawana jest litera w

Przykład: glVertex3iv określa współrzędną wierzchołka, składającą się z trzech liczb całkowitych przekazywanych jako wskaźnik do tablicy.

Grafika

Wszystko obiekty graficzne w OpenGL są zbiorem punktów, linii i wielokątów. Istnieje 10 różnych prymitywów, z których budowane są wszystkie obiekty. Zarówno dwuwymiarowe, jak i trójwymiarowe. Z kolei wszystkie prymitywy są określone punktami - wierzchołkami.

• GL_POINTS- każdy wierzchołek definiuje punkt
• GL_LINES- każda para wierzchołków definiuje linię
• GL_LINE_STRIP- każda para wierzchołków definiuje linię (tzn. koniec poprzedniej linii jest początkiem następnej)
• GL_LINE_LOOP- podobny do poprzedniego, z tą różnicą, że ostatni wierzchołek łączy się z pierwszym i uzyskuje się zamkniętą figurę
• GL_TRÓJKĄTY- każda pojedyncza trójka wierzchołków definiuje trójkąt
• GL_TRIANGLE_STRIP- każdy kolejny wierzchołek definiuje trójkąt wraz z dwoma poprzednimi (okazuje się wstążka z trójkątów)
• GL_TRIANGLE_FAN- każdy trójkąt jest zdefiniowany przez pierwszy wierzchołek i kolejne pary (tj. trójkąty są zbudowane wokół pierwszego wierzchołka, tworząc coś na kształt przepony)
• GL_QUADS- co cztery wierzchołki tworzą czworokąt
• GL_QUAD_STRIP- każdy następna para wierzchołki tworzą czworobok wraz z parą poprzednich
• GL_POLYGON- definiuje wielokąt o liczbie kątów równej liczbie podanych wierzchołków

Aby zdefiniować prymityw, użyj konstrukcji glBegin(typ_pierwotny)...glEnd(). Wierzchołki są określone glVertex*. Wierzchołki są ustawione przeciwnie do ruchu wskazówek zegara. Współrzędne ustawia się od lewego górnego rogu okna. Kolor wierzchołka jest ustawiany za pomocą polecenia glKolor*. Kolor jest określony jako RGB lub RGBA. Polecenie glColor* działa na wszystkie wierzchołki następujące po nim, dopóki nie zostanie napotkane kolejne polecenie glColor*, lub na wszystkie wierzchołki, jeśli nie ma innych poleceń glColor*.
Oto kod rysujący kwadrat o wierzchołkach w różnych kolorach:

1. glZacznij (GL_QUADS) ;
2. glVertex2i(250, 450);
3. glVertex2i(250, 150);
4. glVertex2i(550, 150) ;
5. glVertex2i(550, 450) ;
6. gEnd() ;

Podstawy programu OpenGL

Do pracy niezależnej od platformy z systemem Windows można użyć pliku . GLUT ułatwia pracę z OpenGL.
Aby zainicjować GLUT na początku programu, musisz wywołać glutInit(&argc, argv). Aby ustawić tryb wyświetlania, zadzwoń glutInitDisplayMode(tryb), gdzie tryb może przyjmować następujące wartości:

• GLUT_RBA- zawiera kolor czteroskładnikowy (domyślnie)
• GLUT_RGB- tak samo jak GLUT_RGBA
• GLUT_INDEX- zawiera kolor indeksowany
• GLUT_DOUBLE- włącza podwójny bufor ekranu
• GLUT_POJEDYNCZY- włącza pojedynczy bufor ekranu (domyślnie)
• GLUT_DEPTH- włącza bufor Z (bufor głębokości)
• GLUT_STENCIL- zawiera bufor szablonowy
• GLUT_ACCUM- włącza bufor akumulacyjny
• GLUT_ALPHA- umożliwia mieszanie alfa (przezroczystość)
• GLUT_MULTISPRÓBEK- umożliwia multisampling (antyaliasing)
• GLUT_STEREO- zawiera obraz stereo

Aby wybrać wiele trybów jednocześnie, użyj bitowego OR „|”. Na przykład: glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA|GLUT_DEPTH) włącza podwójne buforowanie, bufor Z i poczwórny kolor. Rozmiary okien są ustawione glutInitWindowSize(szerokość, wysokość). Jego stanowisko jest glutInitWindowPosition(x, y). Funkcja tworzy okno glutUtwórz okno(tytuł_okna).
GLUT implementuje mechanizm sterowany zdarzeniami. Te. Istnieje główna pętla, która rozpoczyna się po inicjalizacji i wszystkie zadeklarowane zdarzenia są już w niej przetwarzane. Na przykład naciśnięcie klawisza na klawiaturze lub przesunięcie kursora myszy itp. Funkcje obsługi zdarzeń można zarejestrować za pomocą następujących poleceń:

• void glutDisplayFunc (void (*func) (void))- ustawia funkcję rysowania obrazu
• void glutReshapeFunc (void (*func) (int szerokość, int wysokość))- ustawia funkcję przetwarzania zmiany rozmiaru okna
• void glutVisibilityFunc (void (*func)(int stan))- ustawia funkcję przetwarzania zmian stanu widoczności okna
• void glutKeyboardFunc (void (*func)(klucz znaku bez znaku, int x, int y))- ustawia funkcję przetwarzania naciśnięć klawiszy klawiatury (tylko te, które generują znaki ASCII)
• void glutSpecialFunc (void (*func)(int klucz, int x, int y))- ustawia funkcję przetwarzania naciśnięć klawiszy klawiatury (takich, które nie generują znaków ASCII)
• void glutIdleFunc (void (*func) (void))- określa funkcję wywoływaną, gdy nie ma innych zdarzeń
• void glutMouseFunc (void (*func) (przycisk int, stan int, int x, int y))- definiuje funkcję przetwarzającą polecenia myszy
• void glutMotionFunc (void (*func)(int x, int y))- definiuje funkcję przetwarzającą ruch kursora myszy po naciśnięciu dowolnego przycisku myszy
• void glutPassiveMotionFunc (void (*func)(int x, int y))- definiuje funkcję przetwarzającą ruch kursora myszy, gdy nie jest wciśnięty żaden przycisk myszy
• void glutEntryFunc (void (*func)(stan int))- definiuje funkcję obsługującą ruch kursora poza oknem i jego powrót
• void glutTimerFunc (unsigned int ms, void (*func)(int wartość), wartość)- określa funkcję wywoływaną na timerze

Następnie możesz rozpocząć pętlę główną glutMainLoop().

Pierwszy program

Teraz znamy podstawy pracy z OpenGL. Możesz pisać prosty program utrwalić wiedzę.
Zacznijmy od dołączenia pliku nagłówkowego GLUT:

Teraz już wiemy co wpisać w pliku main. Zarejestrujmy dwie procedury obsługi: do rysowania zawartości okna i do przetwarzania zmiany rozmiaru. Te dwie procedury obsługi są zasadniczo używane w każdym programie korzystającym z OpenGL i GLUT.

1. int main (int argc, char * argv)
2. glutInit(& argc, argv) ;
3. glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA) ; /*Włącz podwójne buforowanie i kolor czteroskładnikowy*/
4. glutInitWindowSize(800, 600) ;
5. glutCreateWindow("Lekcja OpenGL 1" );
6. glutReshapeFunc(zmiana kształtu) ;
7. glutDisplayFunc(wyświetlanie) ;
8. glutMainLoop() ;
9. zwróć 0;

Teraz musimy napisać funkcję obsługi zmiany rozmiaru okna. Za pomocą polecenia ustawmy obszar wyjściowy obrazu na rozmiar całego okna glViewport(x, y, szerokość, wysokość). Następnie załaduj macierz projekcji glMatrixMode(GL_PROJECTION), zastąp go jednostką glLoadIdentity() i ustaw rzut ortogonalny. Na koniec załaduj macierz widoku modelu glMatrixMode(GL_MODELVIEW) i zastąp go jednostkowym.
W rezultacie otrzymujemy:

1. nieważna zmiana kształtu (int w, int h)
2. glViewport(0, 0, w, h) ;
3. glMatrixMode(GL_PROJECTION) ;
4. glLoadIdentity() ;
5. gluOrtho2D(0, w, 0, h) ;
6. glMatrixMode(GL_MODELVIEW) ;
7. glLoadIdentity() ;

Pozostaje tylko napisać funkcję rysującą zawartość okna. Narysujemy kwadrat, który podałem powyżej jako przykład. Będziesz musiał dodać bardzo mało kodu. Najpierw przed rysowaniem musisz wyczyścić różne bufory za pomocą glWyczyść (tryb). Używany w taki sam sposób jak glutInitDisplayMode. Możliwa wartość:

• GL_COLOR_BUFFER_BIT- aby wyczyścić bufor kolorów
• GL_DEPTH_BUFFER_BIT- aby wyczyścić bufor głębokości
• GL_ACCUM_BUFFER_BIT- wyczyszczenie bufora akumulacji
• GL_STENCIL_BUFFER_BIT- do czyszczenia bufora ekranu

W naszym przypadku musimy jedynie wyczyścić bufor kolorów, ponieważ Nie używamy innych. Po drugie, po narysowaniu musisz poprosić OpenGL o zmianę buforów ekranu za pomocą bufory glutSwap(), ponieważ mamy włączone podwójne buforowanie. Wszystko jest rysowane na buforze ukrytym przed użytkownikiem, a następnie bufory są zmieniane. Ma to na celu uzyskanie płynna animacja i żeby nie było żadnego efektu migotanie ekran.
Otrzymujemy:

1. puste wyświetlanie()
2. glClear(GL_COLOR_BUFFER_BIT) ;
3. glBegin(GL_QUADS) ;
4. glColor3f(1,0, 1,0, 1,0) ;
5. glVertex2i(250, 450);
6. glColor3f(0,0, 0,0, 1,0) ;
7. glVertex2i(250, 150);
8. glColor3f(0,0, 1,0, 0,0) ;
9. glVertex2i(550, 150) ;
10. glColor3f(1,0, 0,0, 0,0) ;
11. glVertex2i(550, 450) ;
12. gEnd() ;
13. glutSwapBuffers() ;

Konkluzja

Wszystko! Można skompilować. Powinno to wyglądać mniej więcej tak:

WSTĘP

OpenGL to jeden z najpopularniejszych interfejsów programowania aplikacji (API – Application Programming Interface) służący do tworzenia aplikacji z zakresu dwuwymiarowego i Grafika 3D.

Standard OpenGL (Open Graphics Library) został opracowany i zatwierdzony w 1992 roku przez wiodące firmy w dziedzinie programowania oprogramowanie jako wydajny, niezależny od sprzętu interfejs nadający się do implementacji na różnych platformach. Standard oparty jest na bibliotece IRIS GL opracowanej przez Silicon Graphics Inc.

Biblioteka zawiera około 120 różnych poleceń, za pomocą których programista określa obiekty i operacje niezbędne do pisania interaktywnych aplikacji graficznych.

Dziś grafika systemu OpenGL obsługiwane przez większość producentów sprzętu i platformy oprogramowania. System ten jest dostępny dla osób pracujących w Środowisko Windowsa, użytkowników komputerów Apple. Wolno dostępny kod Mesa (pakiet API oparty na OpenGL) można skompilować na większości systemów operacyjnych, w tym na Linuksie.

Charakterystycznymi cechami OpenGL, które zapewniły rozpowszechnienie i rozwój tego standardu graficznego są:

Stabilność. Dodatki i zmiany w standardzie wprowadzane są w taki sposób, aby zachować kompatybilność z wcześniej opracowanym oprogramowaniem.

Niezawodność i przenośność. Aplikacje korzystające z OpenGL gwarantują ten sam efekt wizualny niezależnie od rodzaju użytego oprogramowania. system operacyjny i organizacja ekspozycji informacyjnych. Ponadto aplikacje te można uruchamiać na obu komputery osobiste oraz na stacjach roboczych i superkomputerach.

Łatwość użycia. Standard OpenGL ma przemyślaną strukturę i intuicyjny interfejs, który pozwala na tworzenie skuteczne aplikacje, zawierający mniej linii kodu niż w przypadku innych bibliotek graficznych. Niezbędne funkcje zapewniające kompatybilność z różnymi urządzeniami są zaimplementowane na poziomie biblioteki i znacznie upraszczają tworzenie aplikacji.

Dostępność dobra pakiet podstawowy do pracy z aplikacjami 3D ułatwia studentom zrozumienie kluczowych zagadnień kursu grafiki komputerowej - modelowania obiektów 3D, cieniowania, teksturowania, animacji itp. Rozbudowana funkcjonalność OpenGL zapewnia dobrą podstawę do prezentacji teoretycznych i aspekty praktyczne temat.

PROGRAMOWANIE Z WYKORZYSTANIEM BIBLIOTEKI OPENGL

Cel i możliwości biblioteki OpenGL

Aby uprościć tworzenie programów w języku C++, istnieje duża liczba gotowe biblioteki z implementacją algorytmów dla konkretnych obszary podlegające, od obliczeń numerycznych po rozpoznawanie mowy. Biblioteka otwarta GL to jeden z najpopularniejszych interfejsów programistycznych (API), z którym można pracować Grafika 3D. Standard OpenGL został zatwierdzony w 1992 roku przez wiodące firmy tworzące oprogramowanie. Został on oparty na bibliotece IRIS GL, opracowanej przez Silicon Graphics w oparciu o koncepcję maszyny graficznej na Uniwersytecie Stanforda (1982).

OpenGL oznacza otwartą bibliotekę graficzną. Programy korzystające z OpenGL gwarantują takie same efekty wizualne na wielu systemach operacyjnych – na komputerach osobistych, stacjach roboczych i superkomputerach.

Z punktu widzenia programisty OpenGL to interfejs programistyczny dla urządzeń graficznych (takich jak akceleratory graficzne). Zawiera około 150 różnych funkcji, za pomocą których programista może ustawić właściwości różnych obiektów trójwymiarowych i dwuwymiarowych oraz przeprowadzić ich wizualizację (rendering). Te. w programie należy ustawić położenie obiektów w przestrzeni trójwymiarowej, zdefiniować inne parametry (obrót, rozciąganie), ustawić właściwości obiektów (kolor, tekstura, materiał itp.), pozycję obserwatora, a następnie biblioteka OpenGL wygeneruje dwuwymiarową projekcję tej trójwymiarowej sceny.

Można powiedzieć, że biblioteka OpenGL jest biblioteką służącą wyłącznie do wizualizacji scen 3D (biblioteka renderowania). Nie obsługuje żadnych urządzeń peryferyjnych (takich jak klawiatura czy mysz) i nie zawiera narzędzi do zarządzania oknami ekranowymi. Zapewnienie interakcji urządzenia peryferyjne z biblioteką OpenGL na konkretnym systemie operacyjnym jest zadaniem programisty.

Główne możliwości OpenGL udostępnione programiście można podzielić na kilka grup:

1. Prymitywy geometryczne i rastrowe. Wszystkie pozostałe obiekty budowane są na bazie tych prymitywów. Elementami geometrycznymi są punkty, odcinki linii i wielokąty. Elementy rastrowe to mapy bitowe i obrazy.

2. Splajny. Splajny służą do konstruowania gładkich krzywych przy użyciu punktów odniesienia.

3. Przeglądanie i modelowanie transformacji. Transformacje te pozwalają na określenie przestrzennego położenia obiektów, zmianę kształtu obiektów oraz ustawienie położenia kamery, dla której OpenGL buduje wynikowy obraz projekcyjny.

4. Praca z kolorem. Do operacji z kolorem w OpenGL dostępny jest tryb RGBA (czerwony - zielony - niebieski - przezroczystość) oraz tryb indeksowy (kolor jest określony numerem seryjnym w palecie).

5. Usuwanie niewidocznych linii i powierzchni.

6. Podwójne buforowanie. W OpenGL dostępne jest zarówno buforowanie pojedyncze, jak i podwójne. Podwójne buforowanie służy do eliminacji migotania podczas animacji. W tym przypadku obraz każdej klatki jest najpierw rysowany w niewidocznym buforze, a klatka jest kopiowana na ekran dopiero po jej całkowitym narysowaniu.

7. Nakładka tekstury. Tekstury ułatwiają tworzenie realistycznych scen. Jeśli tekstura (jakiś obraz) zostanie nałożona na obiekt, na przykład kulę, wówczas obiekt będzie wyglądał inaczej (na przykład kula będzie wyglądać jak wielokolorowa kula).

8. Wygładzanie. Automatyczne wygładzanie kompensuje postrzępione krawędzie typowe dla wyświetlaczy rastrowych. Podczas wygładzania segmentów OpenGL zmienia intensywność i kolor pikseli, dzięki czemu segmenty te pojawiają się na ekranie bez zygzaków.

9. Oświetlenie. Określanie lokalizacji, natężenia i barwy źródeł światła.

10. Efekty specjalne. Na przykład mgła, dym, przezroczystość obiektów. Narzędzia te sprawiają, że sceny są bardziej realistyczne.

Chociaż biblioteka OpenGL zapewnia prawie wszystkie możliwości modelowania i renderowania scen 3D, niektóre funkcje graficzne bezpośrednio w OpenGL nie są dostępne. Przykładowo, aby ustawić pozycję i kierunek kamery do obserwacji sceny, trzeba będzie obliczyć macierz projekcyjną, co wiąże się z dość uciążliwymi obliczeniami. Dlatego istnieją tak zwane biblioteki pomocnicze dla OpenGL.

Jedna z tych bibliotek nazywa się GLU. Ta biblioteka jest częścią standardu i jest dostarczana z główną biblioteką OpenGL. GLU zawiera więcej niż złożone funkcje(na przykład do utworzenia cylindra lub dysku wymagane jest tylko jedno polecenie). Biblioteka GLU posiada także funkcje do pracy ze splajnami, dodatkowe operacje na macierzach i dodatkowe typy projekcje.

Dwie bardziej znane biblioteki to GLUT (dla Uniksa) i GLAUX (dla MS Windows). Nie tylko zapewniają dodatkową funkcjonalność OpenGL (do budowania skomplikowanych kształtów, takich jak stożki i czworościany), ale mają także funkcje do pracy z oknami, klawiaturą i myszą w aplikacjach konsolowych. Aby pracować z OpenGL na określonym systemie operacyjnym (na przykład Windows lub Unix), musisz przeprowadzić wstępną konfigurację, która zależy od systemu operacyjnego. GLUT i GLAUX pozwalają dosłownie zdefiniować okno, w którym OpenGL będzie działać za pomocą zaledwie kilku poleceń i ustawić funkcje do przetwarzania poleceń z klawiatury lub myszy.

Możliwości OpenGL opisano poprzez funkcje biblioteczne. Wszystkie funkcje można podzielić na pięć kategorii.

Funkcje opisu prymitywnego definiują obiekty niższego poziomu hierarchii (prymitywy), które podsystem graficzny jest w stanie wyświetlić. W OpenGL prymitywami są punkty, linie, wielokąty itp.

Funkcje opisu źródła światła służą do opisu położenia i parametrów źródeł światła znajdujących się w trójwymiarowej scenie.

Funkcje ustawiania atrybutów. Ustawiając atrybuty, programista określa, jak wyświetlane obiekty będą wyglądać na ekranie. Innymi słowy, podczas gdy prymitywy definiują, co pojawi się na ekranie, atrybuty definiują, w jaki sposób będzie to wyświetlane. OpenGL umożliwia ustawienie koloru, charakterystyki materiału, tekstury i parametrów oświetlenia jako atrybutów.

Funkcja wizualizacji pozwala na ustawienie pozycji obserwatora przestrzeń wirtualna, parametry obiektywu aparatu. Znając te parametry, system będzie w stanie nie tylko poprawnie skonstruować obraz, ale także wyciąć obiekty znajdujące się poza polem widzenia.

Zestaw funkcji przekształcenia geometryczne pozwolić programiście to zrobić różne transformacje obiekty - obrót, translacja, skalowanie.

Jednocześnie OpenGL może wykonywać dodatkowe operacje, takie jak wykorzystanie splajnów do konstruowania linii i powierzchni, usuwanie niewidocznych części obrazów, praca z obrazami na poziomie pikseli itp.

W tym rozdziale przyjrzymy się renderowaniu grafiki 3D przy użyciu biblioteki OpenGL, przestudiujemy biblioteki GLU i GLUT (w systemie Linux zamiast tej drugiej używana jest biblioteka FreeGLUT) oraz przeanalizujemy proces ładowania tekstur przy użyciu bibliotek SOIL i DevIL.

Jak już zauważono w rozdz. 9, programiści graficy zwykle nie pracują bezpośrednio z procesorem graficznym. Wynika to zarówno z faktu, że istnieje wiele różnych procesorów graficznych, jak i z faktu, że praca na niskim poziomie z procesorami graficznymi jest dość złożona i zwykle jest wykonywana przez twórców sterowników. Zamiast tego używają różnych interfejsów API, które zapewniają więcej interfejsu wysoki poziom do pracy z GPU. Interfejs ten wyodrębnia konkretny procesor graficzny (wszystko jest obsługiwane przez sterownik, zwykle dostarczany przez producenta procesora graficznego), umożliwiając napisanie przenośnego kodu, który będzie działał na różnych procesorach graficznych. Ponadto taki interfejs API ukrywa przed programistą szereg szczegółów niskiego poziomu dotyczących pracy z procesorem graficznym.

Obecnie głównymi interfejsami API do programowania grafiki 3D są OpenGL i Dircct3D. Ta ostatnia jest specyficzna tylko dla platformy Microsoft Windows. W tej książce opisano podstawy pracy z OpenGL. Jest to wieloplatformowy interfejs API, który obsługuje wszystkie główne systemy operacyjne (Windows, Linux, Mac OS X) i umożliwia pracę z duża ilość różne procesory graficzne.

Istnieje wersja API - OpenGL ES, przeznaczona do pracy urządzenia mobilne. Za jego pomocą możesz stworzyć trójwymiarową grafikę platformy iOS i Androida. Dodatkowo dostępna jest biblioteka WebGL, która umożliwia korzystanie z OpenGL ES bezpośrednio w oknie przeglądarki za pomocą JavaScript. Istnieją również powiązania dla OpenGL, które działają ze wszystkimi głównymi językami programowania, co ułatwia korzystanie z OpenGL z niemal każdego języka programowania.

Głównym zadaniem OpenGL jest renderowanie grafiki dwu- i trójwymiarowej. Co więcej, to API w ogóle nie zajmuje się tworzeniem okien do renderowania, odczytywaniem danych wejściowych od użytkownika i innymi podobnymi pracami, które są w dużym stopniu zależne od konkretnego systemu operacyjnego, dlatego do tych celów użyjemy wieloplatformowej biblioteki GLUT. Ta biblioteka zapewnia proste i wygodnym sposobem do tworzenia okien, renderowania ich przy użyciu OpenGL i odbierania komunikatów za pomocą myszy i klawiatury.

Z architektonicznego punktu widzenia OpenGL jest zbudowany na modelu klient-serwer. W tym przypadku sam program, korzystający z OpenGL, pełni rolę klienta, a procesor graficzny i jego sterownik pełnią rolę serwera. Zwykle program działa na tym samym komputerze, na którym zainstalowany jest procesor graficzny, ale nie jest to konieczne.

W praktyce wszystkie wykonane polecenia OpenGL są buforowane, a następnie umieszczane w kolejce do transmisji do GPU. Zatem wykonanie polecenia procesora tylko to wskazuje to polecenie dostał się do bufora lub został dodany do kolejki; jest całkiem możliwe, że procesor graficzny jeszcze nie zaczął go wykonywać. Jednocześnie OpenGL można uznać za maszyna stanu- ma swój własny stan. Jedynym sposobem na zmianę tego stanu jest użycie poleceń OpenGL. Stan OpenGL nie zmienia się pomiędzy poleceniami.

Ważną koncepcją w OpenGL są bufory (rysunek 10.1). Aby móc renderować, należy utworzyć niezbędne bufory. Bufor koloru jest zawsze używany i dla każdego piksela zapisywany jest jego kolor jako 24-bitowa liczba formacie RGB(8 bitów dla każdego z podstawowych kolorów – czerwonego, zielonego i niebieskiego) lub w formacie 32-bitowym formacie RGBA(do standardowych trzech składników dodawany jest czwarty składnik - alfa, który ustawia krycie).

Używając metody r-buffer do usuwania niewidocznych powierzchni, należy zapisać odpowiednią wartość głębi dla każdego piksela (zwykle wartość głębi jest przechowywana jako 16-, 24- i 32-bitowa liczba całkowita). W związku z tym wszystkie wartości głębokości wzięte razem tworzą bufor głębokości. Możesz także użyć bufor szablonowy, bufor akumulacyjny.

Tworząc okno do renderowania, musisz utworzyć kontekst OpenGL i odpowiednie bufory. Sam kontekst jest zwykle powiązany z bieżącym wątkiem, więc jeśli aplikacja korzysta z wielu wątków, utworzonego kontekstu można tak naprawdę używać tylko z wątku, w którym został utworzony.

Przetwarzanie danych w OpenGL opiera się na potoku renderowania (patrz rysunek 9.1). Potok definiuje główne etapy przetwarzania przychodzących danych. To, jak dokładnie dane zostaną przetworzone, zależy od parametrów stanu OpenGL, ale same te etapy i kolejność ich występowania są ściśle stałe.

Ryż. 10.1.

W przypadku nowoczesnych procesorów graficznych dwie części tego potoku są reprezentowane przez programy działające na procesorze graficznym, zwane modułami cieniującymi. Następnie rozważymy wersję 2 OpenGL, w której programy te nie muszą być jawnie określone: ​​istnieją shadery, które działają domyślnie (to znaczy w przypadku, gdy programista nie określił jawnie odpowiednich shaderów). Począwszy od wersji 3, OpenGL wymaga obowiązkowych shaderów i częściowo psuje kompatybilność z poprzednimi wersjami, dlatego rozważymy Wersja OpenGL 2.

Geometrię definiuje się jako zbiór wierzchołków tworzących różne prymitywy (punkty, odcinki, trójkąty). Na każdym wierzchołku oprócz jego współrzędnych można ustawić także szereg dodatkowych atrybutów, takich jak współrzędne koloru, normalne, tekstury. Dane w każdym wierzchołku stanowią dane wejściowe modułu cieniującego wierzchołków: dla każdego wierzchołka moduł cieniujący wierzchołków wykonuje i generuje pewne wartości wyjściowe. Wymaganą wartością wyjściową są jednolite współrzędne wierzchołków po wykonaniu wszystkich transformacji.

OpenGL wykorzystuje macierze 4x4 do transformacji wierzchołków – macierz projektową widoku modelu (rysunek 10.2). Jeśli moduł cieniujący wierzchołków nie jest wyraźnie określony, używany jest domyślny moduł cieniujący wierzchołków, który mnoży współrzędne wierzchołków (jako wektor o współrzędnych jednorodnych) najpierw przez macierz widoku modelu, a następnie przez macierz projektu.

Następnie prymitywy są składane i odcinane: wszystkie części każdego prymitywu, które wystają poza widoczny obszar (oglądanie ściętego) są automatycznie przycinane, tak że elementy pierwotne w całości zawarte w zakresie są przekazywane do następnego etapu potoku. Następnie nieruchoma część rurociągu dokonuje podziału perspektywicznego – wektor o jednorodnych współrzędnych jest dzielony na jego czwartą składową.

Ryż. 10.2.

Jeżeli współrzędne zostały początkowo określone w ich własnym układzie współrzędnych, wówczas mnożenie przez macierz widoku modelu przenosi je do układu współrzędnych kamery. Dalsze mnożenie przez macierz projekcji prowadzi do uzyskania współrzędnych miejsce na klip. Po wykonaniu podziału perspektywicznego otrzymujemy znormalizowane współrzędne urządzenia (znormalizowane współrzędne urządzenia).

Ostatnim krokiem jest konwersja znormalizowanych współrzędnych na współrzędne okna wyrażone w pikselach.

Przed podziałem perspektywicznym prymitywy są składane, a następnie odcinane: odcinane jest wszystko, co nie mieści się w zakresie widoczności. Następnie każdy prymityw jest rasteryzowany, tj. jest tłumaczony na zbiór fragmentów. Seria wartości określonych w wierzchołkach jest interpolowana, a każdemu fragmentowi nadawana jest odpowiadająca mu wartość. Następnie dla każdego fragmentu wykonywany jest moduł cieniujący fragment, którego zadaniem jest obliczenie koloru dla każdego fragmentu. W tym przypadku stosowane są wartości interpolowane, możliwy jest dostęp do tekstur - wcześniej przygotowanych obrazów, które nakładają się na prymitywy wyjściowe. Należy pamiętać, że każdy fragment ma swoje własne współrzędne na ekranie i wartość głębi uzyskaną w drodze interpolacji. Ponadto moduł cieniujący fragment, zamiast obliczać kolor fragmentu, może jawnie odrzucić cały fragment.

W kolejnym etapie potoku dla każdego fragmentu wykonywana jest grupa kontroli, z których każda może odrzucić dany fragment. Pierwsza z tych kontroli sprawdza, czy dany piksel odpowiada widocznej części okna. Jeśli nie, fragment ten jest natychmiast odrzucany. Następny test sprawdza, czy fragment mieści się w podanym prostokącie (we współrzędnych okna). Istnieją również testy szablonowe i głębokościowe. Test szablonowy pobiera z bufora szablonowego grupę bitów odpowiadającą danemu fragmentowi i sprawdza, czy warunek dla tych bitów jest spełniony. Test głębokości porównuje głębokość fragmentu z odpowiednią wartością z bufora głębokości. Każdy z tych testów może skutkować odrzuceniem odpowiedniego fragmentu. Ponadto istnieje test alfa, który pozwala odrzucić fragmenty na podstawie wartości składnika alfa jego koloru.

Następnie wykonywany jest etap mieszania koloru fragmentu z kolorem odpowiadającym temu fragmentowi w buforze koloru. Ta operacja potrzebne do obsługi półprzezroczystej™.

Obliczenia wartości koloru można dokonać ze znacznie większą precyzją, niż można to zapisać w buforze kolorów. Zwykle w tym przypadku kolor jest po prostu zaokrąglany. Stosowanie rasteryzacja (dithering) zapewnia inną opcję: kolor zmienia się tak, aby średnia sąsiadujących pikseli dała żądaną wartość.

Ostatnim krokiem jest wykonanie podanego bitu działanie logiczne pomiędzy zawartością bufora koloru a wynikową wartością koloru. Należy pamiętać, że wiele z tych testów i operacji można wyłączyć, jeśli nie są potrzebne — zwykle poprawia to wydajność.

Jeśli piszesz program używając OpenGL w C (lub C++), pierwszą rzeczą, którą musisz zrobić, to dołączyć następujący plik nagłówkowy:

Aby zapewnić kompatybilność i przenośność kodu, OpenGL wprowadza szereg własnych typów danych, nazwa każdego z tych typów zaczyna się od przedrostka GL. GLint pasuje standardowy typ całkowite, typ GLuint jest standardowym typem całkowitym bez znaku, a GLfloat jest typem zmiennoprzecinkowym. OpenGL wykorzystuje również kilka typów specjalnych, takich jak GLsizei, który oznacza typ używany do określenia rozmiaru, oraz GLclampf, który służy do określania wartości zmiennoprzecinkowych leżących na linii.

Wprowadzono również specjalny typ GLenum, aby wskazać typ wartości odpowiadających różnym stałym.

Biblioteka OpenGL (jak również dołączone do niej biblioteki GLU i GLUT) zwykle używają dość prostej konwencji nazewnictwa dla stałych i funkcji. Nazwy wszystkich poleceń (funkcji) OpenGL zaczynają się od przedrostka gl (dla funkcji z bibliotek GLU i GLUT - odpowiednio glu i glut).

Nazwy wszystkich stałych zaczynają się od GL_ (odpowiednio od GLU_ i GLUTJ.

Wiele poleceń OpenGL ma wiele poleceń różne opcje, różniących się liczbą przekazywanych argumentów i ich typami. W tym przypadku nazwa polecenia zawiera także specjalny przyrostek zawierający liczbę parametrów oraz przyrostek określający ich typ. Zatem nazwa polecenia w OpenGL zwykle wygląda następująco:

glCommand(1 2 3 4)(b s i f dub us ui)(v)

Opcjonalna liczba służy do określenia liczby przekazanych argumentów (w przypadku, gdy istnieją wersje tego polecenia z inny numer argumenty). Następnie następuje opcjonalny jedno- lub dwuliterowy przyrostek określający typ przekazywanych argumentów (w przypadku, gdy istnieją wersje tego polecenia akceptujące wartości wejściowe różne rodzaje). Sufiks v wskazuje, że pewna liczba parametrów (zwykle jest to zbiór najnowsze parametry) jest przekazywana jako tablica - w rzeczywistości funkcja zamiast tych parametrów otrzymuje wskaźnik do tej tablicy.

Zatem komenda glVertex2i ma dwa argumenty będące liczbami całkowitymi, komenda glColor3f ma trzy argumenty zmiennoprzecinkowe, a komenda glColor4ubv ma cztery argumenty. typ bez znaku bajt, przekazywany jako tablica (czyli funkcja wywołana otrzymuje tylko jeden argument – ​​adres tablicy).

Wyślij swoją dobrą pracę do bazy wiedzy jest prosta. Skorzystaj z poniższego formularza

Studenci, doktoranci, młodzi naukowcy, którzy wykorzystują bazę wiedzy w swoich studiach i pracy, będą Państwu bardzo wdzięczni.

Wysłany dnia http://www.allbest.ru/

OpenGL to interfejs oprogramowania do sprzętu graficznego. Interfejs ten składa się z około 250 oddzielnych poleceń (około 200 poleceń w samym OpenGL i kolejnych 50 w bibliotece narzędzi), które służą do określania obiektów i operacji, które należy wykonać, aby stworzyć interaktywną aplikację graficzną 3D. graficzny interfejs programowania opengl

Biblioteka OpenGL została zaprojektowana jako uogólniony, niezależny interfejs, który można zaimplementować na różnorodnym sprzęcie. Z tego powodu sam OpenGL nie zawiera funkcji służących do tworzenia okien lub przechwytywania danych wprowadzanych przez użytkownika; Do tych operacji musisz użyć narzędzi systemu operacyjnego, w którym pracujesz. Z tych samych powodów OpenGL nie posiada funkcji wysokiego poziomu do opisywania modeli obiektów 3D. Takie polecenia umożliwiłyby opisanie stosunkowo skomplikowanych kształtów, takich jak samochody, części ludzkiego ciała lub cząsteczki. Korzystając z biblioteki OpenGL, musisz zbudować niezbędne modele, korzystając z małego zestawu prymitywów geometrycznych - punktów, linii i wielokątów (wielokątów).

Jednakże bibliotekę zapewniającą opisane możliwości można zbudować na bazie OpenGL. Biblioteka narzędziowa OpenGL (GLU) udostępnia wiele narzędzi do modelowania, takich jak powierzchnie kwadratowe, krzywe i powierzchnie NURBS. GLU jest standardową częścią każdej implementacji OpenGL. Istnieją również biblioteki wyższego poziomu, takie jak Fahrenheit Scene Graph (FSG), które są budowane przy użyciu OpenGL i dystrybuowane oddzielnie dla wielu jego implementacji.

Poniższa lista krótko opisuje podstawowe operacje graficzne, które OpenGL wykonuje w celu wyświetlania obrazów na ekranie.

1. Konstruuje figury z prymitywów geometrycznych, tworząc opis matematyczny obiekty (prymitywami w OpenGL są punkty, linie, wielokąty, bitmapy i obrazy).

2. Umieszcza obiekty w przestrzeni trójwymiarowej i wybiera punkt obserwacyjny, aby obejrzeć powstałą kompozycję.

3. Oblicza kolory dla wszystkich obiektów. Kolory mogą być określane przez aplikację, na podstawie warunków oświetleniowych, obliczonych przy użyciu tekstur nałożonych na obiekty lub dowolnej kombinacji tych czynników.

4. Konwertuje matematyczny opis obiektów i powiązane z nimi informacje o kolorze na piksele na ekranie. Proces ten nazywa się rasteryzacją (lub rasteryzacją).

Na wszystkich tych etapach OpenGL może wykonywać inne operacje, takie jak usuwanie części obiektów ukrytych przez inne obiekty. Oprócz tego, po zrastrowaniu sceny, ale przed wyrenderowaniem jej na ekranie, w razie potrzeby można wykonać pewne operacje na danych pikseli.

Ogólna procedura pracy z biblioteką OpenGl jest następująca:

1. Zainicjuj okno (uzyskaj obszar do wyświetlenia obrazu)

2. Zainstaluj kamerę

3. Włącz światło (jeśli to konieczne)

4. W pętli rozpocznij rysowanie prymitywów (punktów, linii, wielokątów), najpierw czyszcząc okno z poprzedniego rysunku.

Inicjowanie okna.

Jeśli pracujesz w Visual C++, okno zostanie utworzone przy użyciu funkcji

auxInitDisplayMode

Pętla rysowania ramki głównej tworzona jest w funkcji Draw i rejestrowana za pomocą tej funkcji

auxMainLoop(Rysuj);

static void CALLBACK Draw(void) // utworzone przez użytkownika

// pozycja okna OpenGL na ekranie

auxInitPosition(100, 100, oknoW, oknoH);

// ustawienie podstawowych parametrów OpenGL działa

// tryb koloru RGB | włączenie bufora Z do sortowania głębokościowego

// |Podwójne buforowanie

auxInitDisplayMode(AUX_RGB | AUX_DEPTH | AUX_DOUBLE);

// zainicjuj okno OpenGL za pomocą tytułu

if(auxInitWindow("Przykład1") ==GL_FALSE) auxQuit();

// zarejestruj funkcję wywoływaną podczas przerysowywania

// i uruchom pętlę zdarzeń

// Draw() - funkcja użytkownika

auxMainLoop(Rysuj);

Jeśli pracujesz w Borland C++ Builder, to aby zainicjować okno, musisz uzyskać Handle ( unikalny identyfikator Okna okienne) okna, na którym będziesz rysować. Uchwyt jest obecny we wszystkich oknach aplikacji najwyższego poziomu i w większości okien podrzędnych. W naszych przykładach będziemy rysować na oknie potomnym StaticText.

Następnie musimy utworzyć Kontekst Rysunku (kontekst urządzenia) i ustawić jego format. W tym celu inicjowana jest struktura PIXELFORMATDESCRIPTOR (format opisu pikseli). Struktura ta opisuje, czy potrzebujemy obsługi bufora głębokości, podwójnego buforowania itp.).

Następnie postępuj zgodnie z funkcjami:

WybierzFormat piksela

Tworzony jest kontekst rysunkowy OpenGL:

wglCreateContext(hdc);

Następnie łączone są konteksty OpenGL i Windows:

wglMakeCurrent(hdc, hrc)

void __fastcall TFormMain::FormCreate(TObject *Sender)

// weź UCHWYT okna StaticText

statyczny HWND Uchwyt=a->Uchwyt;

// utwórz uchwyt miejsca rysowania dla okna StaticText

hdc = GetDC(Uchwyt);

// ustaw odpowiednie ustawienia kontekstu urządzenia

OPIS FORMATU PIXELÓW pfd = (

rozmiar(PIXELFORMATDESCRIPTOR),

PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,

// wybierz odpowiedni format

PixelFormat = WybierzPixelFormat(hdc, &pfd);

SetPixelFormat(hdc, PixelFormat, &pfd);

// utwórz kontekst urządzenia dla OpenGL

// używając uchwytu miejsca rysunku

hrc = wglCreateContext(hdc);

ShowMessage(:-)~ hrc == NULL");

if(wglMakeCurrent(hdc, hrc) == false)

ShowMessage("Nie udało się utworzyć bieżącego");

Instalacja kamery

Domyślnie kamera jest ustawiona na początku (0, 0, 0), skierowana wzdłuż ujemnego kierunku osi Z, a wektor kierunku w górę to (0, 1, 0).

Aby zainstalować kamerę, wygodnie jest skorzystać z funkcji gluLookAt(). Chociaż ma 9 parametrów, są one łatwe do zrozumienia. Są one podzielone na trzy parametry, odpowiednio dla trzech punktów: Oko (Oko), Środek, Góra.

Oko określa punkt, z którego patrzymy, Centrum określa, gdzie patrzymy, a wektor góry określa, gdzie powinniśmy mieć górę (wyobraźmy sobie pilota samolotu lecącego głową w dół). Wygodnie jest umieszczać wektory w klasach z nadpisanymi operacjami.

gluLookAt(e.x,e.y,e.z, c.x,c.y,c.z, u.x,u.y,u.z);

Główna pętla obejmuje następujące etapy rysowania ramek:

1. Wyczyszczenie buforów z rysowania poprzedniego obrazka

2. Funkcje rysowania prymitywów

3. Funkcje zakończenia rysowania i oczekiwania na odpowiedź z karty graficznej

4. Funkcje kopiowania obrazów z pamięci na ekran

Główna pętla nie obejmuje obsługi zdarzeń, takich jak naciśnięcia klawiszy i zmiana rozmiaru okna. Do obsługi zdarzeń tworzone są osobne funkcje, które dodatkowo dołączane są do aplikacji.

Jeśli pracujesz w Visual C, to odbywa się to za pomocą funkcji, których prototypy opisano w pliku glaux.h:

auxReshapeFunc()

Jeśli pracujesz w Borland C, przetwarzanie zdarzeń odbywa się w tradycyjny sposób dla zdarzeń tworzonych przez to środowisko oprogramowania: po prostu wybierasz komponent (na przykład Button1), tworzysz procedurę obsługi (na przykład naciśnięcie klawisza) i wewnątrz opisz ciało funkcji.

Rysowanie prymitywów

Rysowanie prymitywów odbywa się za pomocą poleceń glBegin() i glEnd().

Stała przekazana do funkcji glBegin określa typ prymitywu, który zostanie narysowany

Współrzędne punktów wyznacza trójwymiarowy wektor przestrzenny. Kolory są określane za pomocą trzech (RGB) lub czterech (RGBA) parametrów. W naszym przykładzie wartość składnika koloru każdego koloru można zmieniać w zakresie od 0 do 1. Jeśli jesteś przyzwyczajony do wartości składnika koloru od 0 do 255 (MsPaint), użyj funkcji glColor3ub(255,0,0 ) funkcja. Przyrostek ub oznacza bajt bez znaku.

Oświetlenie Grafika komputerowa ma 3 elementy

Promieniowanie tła to światło, które jest tak rozproszone przez otoczenie (przedmioty, ściany itp.), że nie można określić jego kierunku – wydaje się, że pochodzi zewsząd. Lampa światło dzienne ma duży składnik tła, ponieważ większość światła docierającego do oka jest najpierw odbijana od wielu powierzchni. światła ma mały element tła: większość światła pada w jednym kierunku, a ponieważ znajduje się na zewnątrz, bardzo niewiele światła uderza w oko po odbiciu się od innych obiektów. Kiedy światło tła uderza w powierzchnię, jest rozprowadzane równomiernie we wszystkich kierunkach.

Składnik rozproszony to światło pochodzące z jednego kierunku, więc wydaje się jaśniejsze, jeśli uderza w powierzchnię pod kątem prostym, i wydaje się przyćmione, jeśli dotyka jej tylko na krótko. Jednak gdy uderza w powierzchnię, rozkłada się równomiernie we wszystkich kierunkach, co oznacza, że ​​jego jasność jest taka sama, niezależnie od tego, z której strony patrzysz na powierzchnię. Jest prawdopodobne, że każde światło pochodzące z określonego kierunku lub położenia ma element rozproszony.

Światło lustrzane pochodzi z określonego kierunku i odbija się od powierzchni w określonym kierunku. Kiedy odzwierciedlasz dobrze skupiony Wiązka laserowa prawie w 100 procentach pochodzi z wysokiej jakości lustra lustrzane odbicie. Błyszczący metal lub plastik ma wysoki połysk, ale kawałek dywanu lub pluszowa zabawka nie. Odbicie lustrzane można porównać do połysku materiału.

Oprócz kolorów tła, rozproszonych i lustrzanych materiały mogą mieć również kolor emisyjny, który symuluje światło pochodzące z samego obiektu. W modelu oświetlenia OpenGL wychodzące światło powierzchniowe zwiększa intensywność obiektu, ale nie ma na nie wpływu żadne źródło światła i nie wytwarza dodatkowego światła dla całej sceny.

Chociaż źródło światła emituje pojedyncza dystrybucja częstotliwości, tło, składniki rozproszone i lustrzane mogą się różnić. Na przykład, jeśli w twoim pokoju są czerwone ściany i białe światło, to światło odbite od ścian będzie bardziej czerwone niż białe (mimo że światło padające na ścianę jest białe). OpenGL pozwala ustawić wartości koloru czerwonego, zielonego i niebieskiego niezależnie dla każdego składnika światła.

Polecenia służące do ustawiania materiału to:

// instancje światła i materiału

// Włącz źródło światła numer zero

glEnable(GL_LIGHT0);

// ustawia położenie i składowe koloru źródła światła

glLightfv(GL_LIGHT0, GL_POSITION, LL.pos);

glLightfv(GL_LIGHT0, GL_AMBIENT, LL.amb);

glLightfv(GL_LIGHT0, GL_DIFFUSE, LL.dif);

glLightfv(GL_LIGHT0, GL_SPECULAR, LL.spec);

// włącz tryb cieniowania/oświetlenia

glEnable(GL_LIGHTING);

// ustaw parametry materiału obiektu

// na przednich ścianach --- GL_FRONT dla tylnych GL_BACK na obu - GL_FRONT_AND_BACK

// drugi parametr - jaki składnik materiału

// możliwe GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_EMISSION, GL_SHININESS

// odpowiednio ROZPROWADZONY, ODBITY, LUSTRO, SAMOEMISJA, wskaźnik odblasków zwierciadlanych

glMaterialfv(GL_FRONT,GL_AMBIENT,MM.amb);

glMaterialfv(GL_FRONT,GL_DIFFUSE,MM.dif);

glMaterialfv(GL_FRONT,GL_SPECULAR,MM.spec);

glMaterialf(GL_FRONT,GL_SHININESS,MM.pos);

glNormal3f(0,0,1);

glBegin(GL_QUADS);

for(i=-10; tj<20;i++)

dla(j=-10;j<20;j++)

glVertex3f(i,j,0);

glVertex3f(i+1,j,0);

glVertex3f(i+1,j+1,0);

glVertex3f(i,j+1,0);

Wniosek

System OpenGL to elastyczny interfejs proceduralny, który pozwala programiście tworzyć różnorodne aplikacje z wykorzystaniem grafiki trójwymiarowej. Norma nie zawiera przepisów dotyczących opisu struktury obiektów graficznych, główną uwagę poświęcono opisowi procesu ich wizualizacji. Dzięki temu wzrasta wydajność istniejącego sprzętu: od prostych urządzeń wykorzystujących jedynie bufor ramki po nowoczesne systemy graficzne potrafiące na poziomie sprzętowym renderować obiekty trójwymiarowe. OpenGL zapewnia jedynie możliwości wyjścia obrazu; organizacja wejścia jest całkowicie pozostawiona konkretnemu systemowi okiennemu, co pozwala na dodatkową niezależność sprzętową aplikacji.

Ze względu na minimalne wykorzystanie skomplikowanych struktur do reprezentacji obiektów trójwymiarowych, możliwe jest wykorzystanie OpenGL jako podstawy do budowania bibliotek do zarządzania obiektami strukturalnymi. Przykładami takich bibliotek są zorientowane obiektowo pakiety narzędzi służące do wizualizacji i modelowania złożonych struktur graficznych

Opublikowano na Allbest.ru

Podobne dokumenty

Kod OpenGL. Składnia poleceń OpenGL. OpenGL jako maszyna stanów. Potok renderowania OpenGL. Biblioteki powiązane z OpenGL. Biblioteka OpenGL. Dołączone pliki. GLUT, zestaw narzędzi bibliotecznych OpenGL.

praca na kursie, dodano 01.06.2004


Programowanie aplikacji z wykorzystaniem biblioteki OpenGL i funkcji rysowania obiektów geometrycznych. Opracowanie procedury wizualizacji trójwymiarowej sceny i interfejsu użytkownika. Struktura logiczna i rozkład funkcjonalny projektu.

praca na kursie, dodano 23.06.2011


Zapoznanie z interfejsem, głównymi cechami i zaletami korzystania z programu OpenGL - popularnej biblioteki do pracy z grafiką 2D i 3D. Uwzględnienie celu, podstawowych komponentów i zasad inicjalizacji silnika oprogramowania DirectX.

prezentacja, dodano 14.08.2013


Tworzenie programu w C++ z wykorzystaniem bibliotek graficznych OpenGL w Microsoft Visual Studio. Budowa dynamicznego obrazu trójwymiarowego modelu obiektu „Platforma wiertnicza”. Struktura logiczna i rozkład funkcjonalny projektu.

praca na kursie, dodano 23.06.2011


Istota programowania z wykorzystaniem biblioteki OpenGL, jej przeznaczenie, architektura, zalety i podstawowe możliwości. Opracowanie aplikacji do konstruowania dynamicznego obrazu trójwymiarowego modelu obiektu Komputer, instrukcja obsługi.

praca na kursie, dodano 22.06.2011


Praca z kolorem z wykorzystaniem biblioteki graficznej OpenGL. Program wyświetlający kwadrat o zmieniającym się kolorze w zależności od zmian gradientów (R, G, B), trójkąt, którego wierzchołki mają różne kolory, prostokątny pasek w postaci widma.

test, dodano 21.01.2011


Cel i standardy implementacji OpenGL dla Windows, kolejność podłączania biblioteki graficznej. Podstawowe funkcje i składnia poleceń. Rysowanie prymitywów, gatunków i przekształceń afinicznych. Modelowanie dwuwymiarowych obiektów graficznych i animacja.

praca laboratoryjna, dodano 07.04.2009


Podstawy programowania z wykorzystaniem biblioteki OpenGL. Aplikacja do budowy dynamicznego obrazu modelu obiektu Batyskaf: opracowanie procedury wizualizacji trójwymiarowego diagramu, interfejsu użytkownika i podsystemu zarządzania zdarzeniami.

praca na kursie, dodano 26.06.2011


Zrozum tę sferę grafiki vikoristannya trivimirnoy. Opis możliwości biblioteki OpenGL. Szczegółowy opis interfejsu programistycznego Borland C++, lista programów demonstrujących jego możliwości. Projekt Rozrakhunok Vitrat na Vikonannya.

praca magisterska, dodana 24.06.2015


Opracowanie komponentu do obliczeń matematycznych (operacji na macierzach) z wykorzystaniem technologii OpenGL (dodawanie, odejmowanie, mnożenie, transpozycja, wyznacznik, macierz odwrotna). Podstawowe umiejętności pracy z technologią w środowisku .Net.

W tej części dowiemy się, jak tworzyć obrazy 3D przy użyciu funkcji biblioteki OpenGL, aby w następnym rozdziale móc opracować aplikację Windows, którą można potraktować jako narzędzie do przeglądania wyników obliczeń naukowych. Materiał zawarty w tej sekcji pozwoli Ci stopniowo nabrać tempa i opanować bardzo atrakcyjną technologię tworzenia i zarządzania obrazami trójwymiarowymi. Najpierw przyjrzymy się podstawowym możliwościom biblioteki OpenGL, następnie nauczymy się zarządzać funkcjami OpenGL na przykładzie prostych aplikacji typu konsolowego, a dopiero potem przystąpimy do tworzenia aplikacji Windows.

Czytelnik prawdopodobnie wie, że OpenGL jest zoptymalizowaną, wysokowydajną biblioteką graficzną zawierającą funkcje i typy danych do wyświetlania grafiki dwu- i trójwymiarowej. Standard OpenGL został zatwierdzony w 1992 roku. Opiera się na bibliotece IRIS GL opracowanej przez Silicon Graphics (www.sgi.com). OpenGL jest obsługiwany na wszystkich platformach. Ponadto OpenGL jest obsługiwany sprzętowo. Istnieją karty graficzne z akceleratorami i wyspecjalizowane karty SD, które wykonują sprzętowo prymitywy OpenGL.

Materiał zawarty w pierwszej części tej lekcji jest inspirowany bardzo dobrą książką (dostępną w Internecie) autorstwa Addison-Wesley, „Przewodnik programowania OpenGL, Oficjalny przewodnik po nauce OpenGL”. Jeżeli czytelnik zna język angielski, zalecamy jego przeczytanie.

Połączone biblioteki

Implementacja OpenGL firmy Microsoft obejmuje pełny zestaw poleceń OpenGL, czyli funkcje globalne zawarte w rdzeniu biblioteki OPENGL32.LIB i posiadające przedrostek gl(np. glLineWidth). Należy pamiętać, że podstawowe funkcje biblioteki mają wiele wersji, co pozwala na określenie żądanego parametru lub ustawienia w dowolny sposób. Zobacz pomoc dotyczącą funkcji z rodziny glColor*. Okazuje się, że aktualny kolor można ustawić na 32 sposoby. Na przykład funkcja:

Void glColorSb(GLbyte czerwony, GLbyte zielony, GLbyte niebieski);

Definiuje kolor za pomocą trzech komponentów typu GLbyte i funkcji:

Unieważnij glColor4dv (const GLdouble *v);

Określa go przy użyciu adresu tablicy czterech komponentów.

Biorąc pod uwagę te opcje, podstawowa biblioteka zawiera ponad 300 poleceń. Dodatkowo można podłączyć bibliotekę narzędzi GLU32.LIB, która uzupełnia główne jądro. Dostępne są funkcje kontroli tekstur, transformacji współrzędnych, generowania kul, cylindrów i dysków, aproksymacji spline krzywych i powierzchni ( NURBY - Niejednorodny racjonalny B-splajn), a także obsługę błędów. Jeszcze jedno, dodatkowe ( pomocniczy) biblioteka GLAUX.LIB pozwala w prosty sposób tworzyć okna Windows, wyświetlać niektóre obiekty SD, obsługiwać zdarzenia wejściowe i kontrolować proces w tle. Niestety ta biblioteka nie jest udokumentowana. Microsoft nie zaleca używania go do tworzenia projektów komercyjnych, ponieważ zawiera kod pętli komunikatów, do którego nie można wstawić przetwarzania innych dowolnych komunikatów.

Notatka
Typ GLbyte jest odpowiednikiem typu char ze znakiem, a GLdouble jest odpowiednikiem typu double. Własne typy są używane w celu uproszczenia przenoszenia na inne platformy. Poniżej podajemy listę typów OpenGL. Czwarty składnik koloru określa przezroczystość koloru, czyli sposób, w jaki kolor tła miesza się z kolorem obrazu. Niektóre polecenia OpenGL mają na końcu literę v, która wskazuje, że argumentem powinien być adres tablicy (wektor). Wektor w matematyce to ciąg liczb (współrzędnych), które jednoznacznie definiują element przestrzeni wektorowej. Wiele poleceń ma wiele wersji, co ostatecznie umożliwia określenie wektora na różne sposoby.

Około dwudziestu funkcji GDI systemu Windows stworzono specjalnie do pracy z OpenGL. Większość z nich ma przedrostek wgl(akronim od Windows GL). Funkcje te są odpowiednikami funkcji z przedrostkiem glx, które łączą OpenGL z platformą X window System. Wreszcie istnieje kilka funkcji Win32 do kontrolowania formatu pikseli i podwójnego buforowania. Mają zastosowanie tylko do wyspecjalizowanych okien OpenGL.