Wizualizacje 3D
Bufor koloru Bufor koloru służy do przechowywania obrazu renderowanej sceny 3D. Typowo OpenGL stosuje dwa bufory koloru: przedni i tylny. Bieżąca scena znajduje się w przednim buforze i jest wyświetlana na ekranie monitora, a jednocześnie w tylnym buforze rysowana jest kolejna ramka sceny. Po zakończeniu rysowania, bufory są zamieniane i cały proces zaczyna się od początku.
Bufor koloru cd. Wybór działania bufora wybiera się na początku działania programu funkcją glutinitdisplaymode( arg ) przyjmuje jako argument maskę bitową GLUT_SINGLE pojedynczy bufor koloru, GLUT_DOUBLE podwójny bufor koloru GLUT_STEREO tryb stereoskopowy Czyszczenie bufora koloru glclearcolor( )
Kolor Kolor w OpenGL może być określany za pomocą 3 lub 4 wartości 3 wartości to kolory R G B (czerwony, zielony, niebieski) 4 wartością to składowa alfa Kolory podawane są w wartościach 0-1
Funkcje ustawiające kolor trzyargumentowe void glcolor3b (GLbyte red, GLbyte green, GLbyte blue) void glcolor3d (GLdouble red, GLdouble green, GLdouble blue) void glcolor3f (GLfloat red, GLfloat green, GLfloat blue) void glcolor3i (GLint red, GLint green, GLint blue) void glcolor3s (GLshort red, GLshort green, GLshort blue) void glcolor3ub (GLubyte red, GLubyte green, GLubyte blue) void glcolor3ui (GLuint red, GLuint green, GLuint blue) void glcolor3us (GLushort red, GLushort green, GLushort blue) void glcolor3bv(const GLbyte *v) void glcolor3dv(const GLdouble *v) void glcolor3fv(const GLfloat *v) void glcolor3iv(const GLint *v) void glcolor3sv(const GLshort *v) void glcolor3ubv(const GLubyte *v) void glcolor3uiv(const GLuint *v) void glcolor3usv(const GLushort *v)
Funkcje ustawiające kolor czteroargumentowe void glcolor4b (GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) void glcolor4d (GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) void glcolor4f (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) void glcolor4i (GLint red, GLint green, GLint blue, GLint alpha) void glcolor4s (GLshort red, GLshort green, GLshort blue, GLshort alpha) void glcolor4ub (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) void glcolor4ui (GLuint red, GLuint green, GLuint blue, GLuint alpha) void glcolor4us (GLushort red, GLushort green, GLushort blue, GLushort alpha) void glcolor4bv(const GLbyte *v) void glcolor4dv(const GLdouble *v) void glcolor4fv(const GLfloat *v) void glcolor4iv(const GLint *v) void glcolor4sv(const GLshort *v) void glcolor4ubv(const GLubyte *v) void glcolor4uiv(const GLuint *v) void glcolor4usv(const GLushort *v)
Kolory tryb indeksowy W trybie indeksowym kolor określany jest pojedyncza liczba indeksem do mapy (tablicy) kolorów, która zawiera informacje o składowych RGB. Typowo wielkość mapy kolorów wynosi od 256 (2 8 ) do 4.096 (2 12 ). Biblioteka OpenGL nie posiada żadnych mechanizmów pozwalających na zmianę zawartości mapy kolorów void glindexd (GLdouble c) void glindexf (GLfloat c) void glindexi (GLint c) void glindexs (GLshort c) void glindexdv (const GLdouble *c) void glindexfv (const GLfloat *c) void glindexiv (const GLint *c) void glindexsv (const GLshort *c)
Cieniowanie Cieniowaniem nazywamy metodę ustalania koloru poszczególnych pikseli wielokąta. Dwa modele cieniowania: cieniowanie płaskie oraz cieniowanie gładkie. W cieniowaniu płaskim wielokąt otrzymuje jeden kolor - określony dla ostatniego wierzchołka (wyjątek stanowi prymityw GL_POLYGON, o kolorze którego decyduje kolor określony dla pierwszego wierzchołka). Cieniowanie gładkie wykorzystuje algorytm Gourauda Wybór cieniowania: void glshademodel (GLenum mode) GL_FLAT - cieniowanie płaskie, GL_SMOOTH - cieniowanie gładkie.
Dithering Kiedy w systemie dostępna jest niewielka liczba kolorów, OpenGL może symulować kolory za pomocą ditheringu. Algorytm polega na umieszczaniu kolorowych pikseli tak aby sprawiały wrażenie jednolitej barwy Włączenie: glenable(gl_dither); Wyłączenie: gldisable(gl_dither);
Przykład #include <GL/glut.h> GLenum shading_model = GL_SMOOTH; bool dithering = true; GLfloat red = 1.0, green = 1.0, blue = 1.0; int main (int argc, char *argv[]) glutinit (&argc,argv); glutinitdisplaymode (GLUT_DOUBLE GLUT_RGB); glutinitwindowsize (500,500); glutcreatewindow ("Trojkat"); glutdisplayfunc (Display); glutreshapefunc (Reshape); glutkeyboardfunc (Keyboard); glutmainloop (); return 0;
Przykład cd. void Reshape (int width, int height) glviewport (0,0,width,height); glmatrixmode (GL_PROJECTION); glloadidentity (); gluortho2d (0,1,0,1); Display (); void Keyboard (unsigned char key, int x, int y) if (key == 'R' && red < 1.0) red += 0.05; if (key == 'r' && red > 0.0) red -= 0.05; if (key == 'B' && blue < 1.0) blue += 0.05; if (key == 'b' && blue > 0.0) blue -= 0.05; if (key=='f') shading_model = GL_FLAT; if (key=='s') shading_model = GL_SMOOTH; if (key=='d') dithering =!dithering; Display (); if (key == 'G' && green < 1.0) green += 0.05; if (key == 'g' && green > 0.0) green -= 0.05;
void Display () glclearcolor (1.0,1.0,1.0,1.0); glclear (GL_COLOR_BUFFER_BIT); glmatrixmode (GL_MODELVIEW); glloadidentity (); if (dithering == true) glenable (GL_DITHER); glshademodel (shading_model); glbegin (GL_TRIANGLES); glcolor3f (red,0.0,0.0); glvertex2f (0.1,0.1); glcolor3f (0.0,green,0.0); glvertex2f (0.9,0.3); glcolor3f (0.0,0.0,blue); glvertex2f (0.3,0.9); glend (); gldisable (GL_DITHER); glflush (); glutswapbuffers ();
Mapy bitowe OpenGL posiada także wsparcie do klasycznej grafiki rastrowej. Mapy bitowe to prostokątne tablice liczb. Dane tablicy zawierającej mapą bitową przyjmują tylko dwie wartości: 0 lub 1 Rysowane są jedynie piksele o wartości 1. Piksele o wartości 0 są pomijane i nie wpływają na zawartość bufora kolorów. Kolor określany jest funkcją glcolor
Ustalenie położenia mapy bitowej Pozycja rastra (mapy bitowej) określają funkcje grupy glrasterpos : void glrasterpos2d( GLdouble x, GLdouble y ) void glrasterpos2f( GLfloat x, GLfloat y ) void glrasterpos2i( GLint x, GLint y ) void glrasterpos2s( GLshort x, GLshort y ) void glrasterpos2dv( const GLdouble * v ) void glrasterpos2fv( const GLfloat * v ) void glrasterpos2iv( const GLint * v ) void glrasterpos2sv( const GLshort * v ) Wersje 3d void glrasterpos3d( GLdouble x, GLdouble y, GLdouble z ) void glrasterpos3f( GLfloat x, GLfloat y, GLfloat z ) void glrasterpos3i( GLint x, GLint y, GLint z ) void glrasterpos3s( GLshort x, GLshort y, GLshort z ) void glrasterpos3dv( const GLdouble * v ) void glrasterpos3fv( const GLfloat * v ) void glrasterpos3iv( const GLint * v ) void glrasterpos3sv( const GLshort * v )
Rysowanie mapy bitowej Rysowanie mapy bitowej w określonej pozycji wykonuje funckja: void glbitmap( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap ) Gdzie: width - szerokość mapy bitowej w pikselach, height - wysokość mapy bitowej w pikselach, xorig, yorig - współrzędne początku układu współrzędnych mapy bitowej liczone względem jej lewego dolnego wierzchołka, xmove, ymove - współrzędne wektora przesunięcia pozycji rastra wykonywanego po narysowaniu mapy bitowej, bitmap - wskaźnik do danych bitmapy.
Parametry mapy bitowej Mapa bitowa jest zapisana odwrotnie (od dolnego do górnego wiersza). Funkcja do ustalenia parametrów zapisu (PACK) lub odczytu (UNPACK) mapy bitowej void glpixelstoref( GLenum pname, GLfloat param ) void glpixelstorei( GLenum pname, GLint param ) pname nazwa parametru, który ma zostać zmodyfikowany, param wartość nowego parametru
Parametry mapy bitowej
Parametry zapisu mapy bitowej GL_PACK_SWAP_BYTES kolejność zapisanych bajtów GL_FALSE normalny odczyt bajtów b0b1b2b3 GL_TRUE odwrócenie bajtów b3b2b1b0 GL_PACK_LSB_FIRST kolejność zapisu bitów w bajcie danych GL_TRUE - bity uporządkowane są od najmniej do najbardziej znaczącego GL_FALSE bity od najbardziej znaczącego do najmniej znaczącego GL_PACK_ROW_LENGTH - określenie szerokości zapisywanej mapy bitowej, gdy jest ona węższa niż cała mapa bitowa (rys) 0 mapa bitowa ma wartość width z funkcji glbitmap GL_PACK_SKIP_PIXELS określenie liczbę początkowych pikseli w wierszu pomijanych podczas zapisu mapy bitowej (rys) GL_PACK_SKIP_ROWS określa liczbę (dolnych) wierszy pomijanych podczas zapisu mapy bitowej (rys) GL_PACK_ALIGNMENT - wielokrotność (w bajtach) długości pojedynczego wiersza danych zapisywanych do pamięci; domyślnie 4 bajty, pozostałe dopuszczalne wartości to1, 2 i 8
Parametry odczytu mapy bitowej GL_UNPACK_SWAP_BYTES kolejność odczytu bajtów GL_FALSE normalny odczyt bajtów b0b1b2b3 GL_TRUE odwrócenie bajtów b3b2b1b0 GL_UNPACK_LSB_FIRST kolejność odczytu bitów w bajcie danych GL_TRUE - bity uporządkowane są od najmniej do najbardziej znaczącego GL_FALSE bity od najbardziej znaczącego do najmniej znaczącego GL_UNPACK_ROW_LENGTH - określenie szerokości odczytywanej mapy bitowej, gdy jest ona węższa niż cała mapa bitowa (rys) 0 mapa bitowa ma wartość width z funkcji glbitmap GL_UNPACK_SKIP_PIXELS określenie liczbę początkowych pikseli w wierszu pomijanych podczas odczytu mapy bitowej (rys) GL_UNPACK_SKIP_ROWS określa liczbę (dolnych) wierszy pomijanych podczas odczytu mapy bitowej (rys) GL_UNPACK_ALIGNMENT - wielokrotność (w bajtach) długości pojedynczego wiersza danych odczytywanych z pamięci; domyślnie 4 bajty, pozostałe dopuszczalne wartości to1, 2 i 8
Przykład #include <vector> #include <GL/glut.h> // współrzędne pozycji rastra map bitowych std::vector < GLint > raster_x; std::vector < GLint > raster_y; // mapa bitowa - litera F GLubyte letterf[ ] = 0xC0, 0x00, // 1100000000000000 0xC0, 0x00, // 1100000000000000 0xC0, 0x00, // 1100000000000000 0xC0, 0x00, // 1100000000000000 0xC0, 0x00, // 1100000000000000 0xC0, 0x00, // 1100000000000000 0xC0, 0x00, // 1100000000000000 0xFC, 0x00, // 1111110000000000 0xFC, 0x00, // 1111110000000000 0xC0, 0x00, // 1100000000000000 0xC0, 0x00, // 1100000000000000 0xC0, 0x00, // 1100000000000000 0xC0, 0x00, // 1100000000000000 0xC0, 0x00, // 1100000000000000 0xFF, 0xFF, // 1111111111111111 0xFF, 0xFF // 1111111111111111 ; int main( int argc, char * argv[] ) glutinit( & argc, argv ); glutinitdisplaymode( GLUT_DOUBLE GLUT_RGB ); glutinitwindowsize( 500, 500 ); glutcreatewindow( "Mapy bitowe" ); glutdisplayfunc( Display ); glutreshapefunc( Reshape ); glutmousefunc( MouseButton ); glutmainloop(); return 0;
void Display() glclearcolor( 1.0, 1.0, 1.0, 1.0 ); glclear( GL_COLOR_BUFFER_BIT ); glmatrixmode( GL_MODELVIEW ); glloadidentity(); glcolor3f( 0.0, 1.0, 0.0 ); glrectf( 100, 100, glutget( GLUT_WINDOW_WIDTH ) - 100, glutget( GLUT_WINDOW_HEIGHT ) - 100 ); void Reshape( int width, int height ) glviewport( 0, 0, width, height ); glmatrixmode( GL_PROJECTION ); glloadidentity(); gluortho2d( 0, width, 0, height ); Display(); glcolor3f( 1.0, 0.0, 0.0 ); glpixelstorei( GL_UNPACK_ALIGNMENT, 2 ); for( unsigned int i = 0; i < raster_x.size(); i++ ) glrasterpos2i( raster_x[ i ], raster_y[ i ] ); glbitmap( 8, 16, 0, 0, 0, 0, letterf ); glflush(); glutswapbuffers(); void MouseButton( int button, int state, int x, int y ) if( button == GLUT_LEFT_BUTTON && state == GLUT_DOWN ) raster_x.insert( raster_x.end(), x ); raster_y.insert( raster_y.end(), glutget( GLUT_WINDOW_HEIGHT ) - y ); Display();
Wersja OpenGL Funkcje do sprawdzenia wersji OpenGL const GLubyte *glgetstring (GLenum name) GL_VENDOR - autor implementacji OpenGL, GL_RENDERER - nazwa urządzenia renderującego, np. karty graficznej, GL_VERSION - numer wersji implementacji OpenGL w formacie: wersja.podwersja lub wersja.podwersja.wydanie oraz opcjonalnie po pojedynczej spacji producent biblioteki, GL_EXTENSIONS - wykaz obsługiwanych rozszerzeń OpenGL. Nazwy obsługiwanych rozszerzeń biblioteki OpenGL oddzielone są pojedyncza spacja.
Wersja biblioteki GLU const GLubyte *glugetstring (GLenum name) Parametr name przyjmuje jedna z dwóch wartości: GLU_VERSION i GLU_EXTENSIONS
Wyświetlenie tekstu w OpenGL Wyświetlanie ciągów znaków umożliwia funkcja void glutbitmapcharacter (void *font, int character) parametr font określa rodzaj wyświetlanej czcionki bitmapowej, a character znak jaki ma zostać wyświetlony Czcionki bitmapowe są na stałe zapisane w bibliotece. GLUT jako mapy bitowe. Są one kodowane w ISO 8859-1, czyli bez polskich liter.
Czcionki bitmapowe GLUT_BITMAP_8_BY_13 - typowa czcionka o wymiarach znaków 8 13 pikseli; znaki ASCII z przedziału [0, 255]; GLUT_BITMAP_9_BY_15 - typowa czcionka o wymiarach znaków 9 15 pikseli; GLUT_BITMAP_TIMES_ROMAN_10-10-punktowa czcionka proporcjonalna Times Roman; znaki ASCII z przedziałów: [32, 126] i [160, 255]; GLUT_BITMAP_TIMES_ROMAN_24-24-punktowa czcionka proporcjonalna Times Roman; znaki ASCII z przedziałów: [32, 126] i [160, 255]; GLUT_BITMAP_HELVETICA_10-10-punktowa czcionka proporcjonalna Helvetica; znaki ASCII z przedziałów: [32, 126] i [160, 255]; GLUT_BITMAP_HELVETICA_12-12-punktowa czcionka proporcjonalna Helvetica; znaki ASCII z przedziałów: [32, 126] i [160, 255]; GLUT BITMAP HELVETICA 18-18-punktowa czcionka proporcjonalna Helvetica; znaki ASCII z przedziałów: [32, 126] i [160, 255];
Pisanie tekstu na ekranie Funkcja określająca położenie wyświetlanej grafiki rastrowej (w tym przypadku litery) void glrasterpos2i (GLint x, GLint y) void glrasterpos2f (GLfloat x, GLfloat y) Polecenia wyświetlające pojedynczą literę w punkcie x, y (z=0) glrasterpos2f (x,y); glutbitmapcharacter(glut_bitmap_helvetica_10, 'x'); Wersja z 3 wymiarami: void glrasterpos3i (GLint x, GLint y, GLint z) void glrasterpos3f (GLfloat x, GLfloat y, GLfloat z)
Przykład Funkcja wyświetlająca tekst w punkcie x,y (tablicę znaków zakończoną 0) void DrawString (int x, int y, char *string) glrasterpos2f (x,y); int len = strlen (string); for (int i = 0; i < len; i++) glutbitmapcharacter(glut_bitmap_helvetica_10, string [i]);
#include <GL/glut.h> #include <stdlib.h> #include <string.h> int main (int argc, char *argv[]) glutinit (&argc,argv); glutinitdisplaymode (GLUT_DOUBLE GLUT_RGB); glutinitwindowsize (600,600); glutcreatewindow ("Wersja OpenGL"); glutdisplayfunc (Display); glutreshapefunc (Reshape); glutmainloop (); return 0;
void Reshape (int width, int height) glviewport (0,0,width,height); glmatrixmode (GL_PROJECTION); glloadidentity (); gluortho2d (0,width-1,0,height-1); Display (); void Display () glclearcolor (1.0,1.0,1.0,1.0); glclear (GL_COLOR_BUFFER_BIT); glcolor3f (0.0,0.0,0.0); char string [2048]; strcpy (string,"gl_renderer: "); strcat (string,(char*)glgetstring (GL_RENDERER)); DrawString (0,height,string); height -= 16; strcpy (string,"gl_version: "); strcat (string,(char*)glgetstring (GL_VERSION)); DrawString (0,height,string); height -= 16; strcpy (string,"glu_version: "); strcat (string,(char*)glugetstring (GLU_VERSION)); DrawString (0,height,string); height -= 16; GLuint height = glutget (GLUT_WINDOW_HEIGHT) - 15; GLuint width = glutget (GLUT_WINDOW_WIDTH); strcpy (string,"gl_vendor: "); strcat (string,(char*)glgetstring (GL_VENDOR)); DrawString (0,height,string); height -= 16; glflush (); glutswapbuffers();
Bufor głębokości Bufor głębokości to obok bufora koloru podstawowy element bufora ramki czyli pamięci obrazu. Bufor głębokości, nazywany także z-buforem lub buforem głębi, uczestniczy w procesie usuwania niewidocznych elementów renderowanej sceny. Działanie bufora głębokości polega w uproszczeniu na przechowywaniu wartości współrzędnej z (głębokości) dla każdego piksela obrazu. Przy rysowaniu kolejnych pikseli danego obiektu obliczana jest wartość współrzędnej z i porównywana z wartością znajdująca się w buforze. Jeżeli porównanie wskazuje, ze rysowany piksel przesłania to, co zostało narysowane wcześniej, zmieniana jest zarówno zawartość bufora głębokości jak i bufora koloru.
Ustawienie bufora głębokości Korzystając z biblioteki GLUT, niezbędne jest dodanie stałej GLUT_DEPTH do wywołania funkcji glutinitdisplaymode Włączenie testowania głębokości wykonuje się poleceniem: glenable(gl_depth_test) Wyłączenie zapisywania wartości współrzędnych do bufora głębokości realizuje funkcja: void gldepthmask (GLboolean flag) Przyjmująca wartości GL_TRUE lub GL_FALSE
Testy bufora głębokości Biblioteka OpenGL umożliwia wybór rodzaju testu wykonywanego przy użyciu danych zawartych w buforze głębokości. Umożliwia to funkcja: void gldepthfunc (GLenum func) GL_NEVER - wartość testu zawsze negatywna, GL_LESS - wartość testu pozytywna jeżeli testowana wartość współrzędnej z jest mniejsza od wartości znajdującej się w buforze; wartość domyślna, GL_EQUAL - wartość testu pozytywna jeżeli testowana wartość współrzędnej z jest równa wartości znajdującej się w buforze, GL_LEQUAL - wartość testu pozytywna jeżeli testowana wartość współrzędnej z jest mniejsza lub równa wartości znajdującej się w buforze, GL_GREATER - wartość testu pozytywna jeżeli testowana wartość współrzędnej z jest większa od wartości znajdującej się w buforze, GL_NOTEQUAL - wartość testu pozytywna jeżeli testowana wartość współrzędnej z jest różna od wartości znajdującej się w buforze, GL_GEQUAL - wartość testu pozytywna jeżeli testowana wartość współrzędnej z jest większa lub równa wartości znajdującej się w buforze, GL_ALWAYS - wartość testu zawsze pozytywna.
Czyszczenie bufora głębokości Przez rozpoczęciem rysowania elementów sceny 3D konieczne jest wyczyszczenie zawartości bufora głębokości. Wymaga to dodania stałej GL_DEPTH_BUFFER_BIT przy wywołaniu funkcji glclear glclear(gl_depth_buffer_bit); Standardowo bufor głębokości zawiera liczby z przedziału [0,1] i jest czyszczony liczba 1. Można to zmienić wywołując funkcję void glcleardepth (GLclampd depth) depth jest liczba z przedziału [0, 1]
Zakres wartości bufora głębokości Bufor głębokości zawiera standardowo liczby z przedziału [0, 1]. Możliwa jest zmiana tego przedziału poprzez użycie funkcji: void gldepthrange (GLclampd znear, GLclampd zfar) Parametr znear określa minimalna wartość w buforze głębokości, a zfar maksymalna wartość w buforze głębokości. Wartości domyślne wynoszą oczywiście 0 i 1.
Przykład #include <GL/glut.h> const GLdouble left = -2.0; const GLdouble right = 2.0; const GLdouble bottom = -2.0; const GLdouble top = 2.0; const GLdouble near_ = 3.0; const GLdouble far_ = 7.0; void Reshape (int width, int height) glviewport (0,0,width,height); glmatrixmode (GL_PROJECTION); glloadidentity (); glfrustum (left,right,bottom,top,near_,far_); Display (); GLfloat rotatex = 0.0; GLfloat rotatey = 0.0; GLenum depth_test = GL_LESS; int main (int argc, char *argv[]) glutinit (&argc,argv); glutinitdisplaymode (GLUT_DOUBLE GLUT_RGB GLUT_DEPTH); glutinitwindowsize (500,500); glutcreatewindow ("Szescian 5"); glutdisplayfunc (Display); glutreshapefunc (Reshape); glutspecialfunc (SpecialKeys); glutkeyboardfunc (Keyboard); glutmainloop (); return 0;
void SpecialKeys (int key, int x, int y) switch (key) case GLUT_KEY_LEFT: rotatey -= 3; break; case GLUT_KEY_UP: rotatex -= 3; break; case GLUT_KEY_RIGHT: rotatey += 3; break; case GLUT_KEY_DOWN: rotatex += 3; break; Reshape (glutget (GLUT_WINDOW_WIDTH),glutGet (GLUT_WINDOW_HEIGHT)); void Keyboard (unsigned char key, int x, int y) if (key=='1') depth_test = GL_NEVER; if (key=='2') depth_test = GL_LESS; if (key=='3') depth_test = GL_EQUAL; if (key=='4') depth_test = GL_LEQUAL; if (key=='5') depth_test = GL_GREATER; if (key=='6') depth_test = GL_NOTEQUAL; if (key=='7') depth_test = GL_GEQUAL; if (key=='8') depth_test = GL_ALWAYS; Display ();
void Display () glclearcolor (1.0,1.0,1.0,1.0); glclear (GL_COLOR_BUFFER_BIT GL_DEPTH_BUFFER_BIT); glmatrixmode (GL_MODELVIEW); glloadidentity (); glcolor3f (0,0,0); glvertex3f (-1.0,-1.0,-1.0); glcolor3f (0,0,1); glvertex3f (-1.0,1.0,-1.0); glcolor3f (0,1,1); glvertex3f (1.0,1.0,-1.0); gltranslatef (0,0,-(near_+far_)/2); glrotatef (rotatex,1.0,0,0); glrotatef (rotatey,0,1.0,0); glscalef (1.15,1.15,1.15); glenable (GL_DEPTH_TEST); gldepthfunc (depth_test); glcolor3f (0,1,0); glvertex3f (1.0,-1.0,-1.0); glcolor3f (0,0,0); glvertex3f (-1.0,-1.0,-1.0); glcolor3f (0,1,1); glvertex3f (1.0,1.0,-1.0); glend (); glbegin (GL_TRIANGLES); glcolor3f (1,0,0); glvertex3f (-1.0,-1.0,1.0); glcolor3f (1,1,0); glvertex3f (1.0,-1.0,1.0); glcolor3f (1,1,1); glvertex3f (1.0,1.0,1.0); ( ) glflush (); glutswapbuffers();
Przesunięcie wartości głębi Mechanizm pozwalający na przesuwanie wartości głębi pikseli przy rysowaniu wielokątów umożliwia funkcja void glpolygonoffset (GLfloat factor, GLfloat units) Gdzie factor i units domyślnie ustawione są na 0. Włącznie mechanizmu przesuwania wartości głębi włącza się poleceniem glenable( ) przekazując jeden z parametrów: GL_POLYGON_OFFSET_POINT - przesuwanie wartości głębi, gdy rysowane są tylko wierzchołki wielokątów, GL_POLYGON_OFFSET_LINE - przesuwanie wartości głębi, gdy rysowane są tylko krawędzie wielokątów, GL_POLYGON_OFFSET_FILL - przesuwanie wartości głębi, gdy rysowane są wypełnione wielokąty.
Przykład glcolor3f(1,0,0); glutsolidsphere(1,10,10); glcolor3f(0,0,0); glutwiresphere(1,10,10); glpolygonoffset(1,1); glenable(gl_polygon_offset_fill); glcolor3f(1,0,0); glutsolidsphere(1,10,10); glcolor3f(0,0,0); glutwiresphere(1,10,10);
Figury 3d wypełnione z biblioteki GLUT Kula void glutsolidsphere (GLdouble radius, GLint slices, GLint stacks) radius - promien kuli, slices - ilosc południków, stacks - ilosc równolezników. Sześcian void glutsolidcube (GLdouble size) size długość boku
Gotowe obiekty 3D z biblioteki GLUT cd Stożek void glutsolidcone (GLdouble base, GLdouble height, GLint slices, GLint stacks) base - promien podstawy stozka, height - wysokosc stozka, slices - ilosc tworzacych, stacks - ilosc południków Torus void glutsolidtorus (GLdouble innerradius, GLdouble outerradius, GLint sides, GLint rings) innerradius - promien koła tworzacego torus, outerradius - promien torusa, sides - ilosc scian bocznych, z których składa sie pojedynczy walec, rings - ilosc walców, z których składa sie torus
Gotowe obiekty 3D z biblioteki GLUT cd. Dwunastościan void glutsoliddodecahedron (void) Czajnik void glutsolidteapot (GLdouble size) size wielkość Ośmiościan void glutsolidoctahedron (void) Czworościan void glutsolidtetrahedron (void) Dwudziestoscian void glutsolidicosahedron (void)
Wybór, który z buforów składających się na bufor koloru wykorzystywany jest do renderingu umożliwia funkcja gldrawbuffer( ) Przekazywanymi argumentami mogą być GL_BACK, GL_FRONT, GL_NONE
Przykład glpolygonoffset(1,1); glenable(gl_polygon_offset_fill); glpushmatrix(); glrotatef(angle, 0, 1, 0); glcolor3f(1,0,0); glutsolidsphere(0.8, 10, 10); glcolor3f(0,0,0); glutwiresphere(0.8, 10, 10); glpopmatrix(); gldrawbuffer( GL_NONE ); glcolor3f (1.0,1.0,0.0); glbegin(gl_quads); glvertex3f(-0.6, -0.6, 1.01); glvertex3f( 0.6, -0.6, 1.01); glvertex3f( 0.6, 0.6, 1.01); glvertex3f(-0.6, 0.6, 1.01); glend(); gldrawbuffer( GL_BACK ); glcolor3f (1.0,1.0,1.0); glutsolidcube(2); glcolor3f (0.0,0.0,0.0); glutwirecube(2);
Listy wyświetlania Zasada działania list wyświetlania sprowadza się do grupowania (zwanego czasami niesłusznie kompilowaniem ) poleceń biblioteki OpenGL. Tak utworzona grupa poleceń identyfikowana jest identyfikatorem w postaci liczby całkowitej. Identyfikator ten umożliwia późniejsze wywołanie wybranej listy wyświetlania, czyli wykonanie poleceń biblioteki OpenGL w niej zapamiętanych. Może się przyczynić do zwiększenia szybkości wyświetlania grafiki.
Tworzenie listy wyświetlania Generowanie nowej listy wyświetlania rozpoczyna się poprzez wywołanie funkcji: void glnewlist (GLuint list, GLenum mode) list określa unikatowy identyfikator listy wyświetlania (musi to byc liczba wieksza od 0), mode definiuje tryb tworzenia listy wyświetlania GL_COMPILE - lista generowana w trybie zachowanym (ang. retained mode); polecenia umieszczane są na liście ale nie są wykonywane, GL_COMPILE_AND_EXECUTE - lista generowana w trybie bezpośrednim (ang. immediate mode); polecenia umieszczane są na liście i jednocześnie natychmiast wykonywane. Zakończenie tworzenia listy wyświetlania void glendlist ()
Generowanie numerów list Serie identyfikatorów do pustych list wyświetlania generuje funkcja: GLuint glgenlists (GLsizei range) zwraca numer identyfikatora pierwszej utworzonej listy wyświetlania. Następne utworzone listy maja identyfikatory o kolejnych wartościach aż do range-1
Listy wyświetlania void gldeletelists (GLuint list, GLsizei range) list - identyfikator pierwszej usuwanej listy range - ilość kolejnych list do usunięcia. Wywołanie poleceń listy wyświetlania void glcalllist (GLuint list) Wywołanie kolejno większej liczby listy wyświetlania void glcalllists (GLsizei n, GLenum type, const GLvoid *lists) n - określa liczbę elementów tablicy type - rodzaj elementów tablicy określa parametr,
Przykład #include <stdlib.h> #include <time.h> #include "glut.h" #include "colors.h" const GLdouble left = -2.0; const GLdouble right = 2.0; const GLdouble bottom = -2.0; const GLdouble top = 2.0; const GLdouble near = 3.0; const GLdouble far = 9.0; GLfloat rotatex = 0.0; GLfloat rotatey = 0.0; int drzewolist; int laslist; void Tree() glpolygonoffset(1,1); glenable(gl_polygon_offset_fill); glpushmatrix(); glscalef(0.5,0.5,0.5); glpushmatrix(); gltranslatef(0,0.3,0); glrotatef(-90,1,0,0); glcolor3f(0,1,0); glutsolidcone(0.5,1,10,10); glcolor3f(0,0,0); glutwirecone(0.5,1,10,10); glpopmatrix(); glpushmatrix(); glscalef(1,3,1); glcolor3f(1,0,0); glutsolidcube(0.2); glcolor3f(0,0,0); glutwirecube(0.2); glpopmatrix(); glpopmatrix();
void GenerateListDrzewo() drzewolist = glgenlists(1); glnewlist(drzewolist, GL_COMPILE); Tree(); glendlist(); void GenerateListLas() laslist = glgenlists(1); glnewlist(laslist, GL_COMPILE); srand(time(0)); for (int i=0; i<20; i++) float x = rand()/(float)rand_max * 4-2; float z = rand()/(float)rand_max * 4-2; glpushmatrix(); gltranslatef(x,0,z); Tree(); glpopmatrix(); glendlist();
void Display () glenable(gl_depth_test); glclearcolor (0.0,0.0,0.0,0.0); glclear (GL_COLOR_BUFFER_BIT GL_DEPTH_BUFFER_BIT); glmatrixmode (GL_MODELVIEW); glloadidentity (); gltranslatef (0,0,-(near+far)/2); void Reshape (int width, int height) glviewport (0,0,width,height); glmatrixmode (GL_PROJECTION); glloadidentity (); glfrustum (left,right,bottom,top,near,far); Display (); glrotatef (rotatex,1.0,0,0); glrotatef (rotatey,0,1.0,0); glcalllist(laslist); glflush (); glutswapbuffers();
void SpecialKeys (int key, int x, int y) switch (key) case GLUT_KEY_LEFT: case GLUT_KEY_UP: case GLUT_KEY_RIGHT: rotatey += 2; break; case GLUT_KEY_DOWN: rotatey -= 2; break; rotatex -= 2; break; rotatex += 2; break; int main (int argc, char *argv[]) glutinit (&argc,argv); glutinitdisplaymode (GLUT_DOUBLE GLUT_RGB GLUT_DEPTH); glutinitwindowsize (500,500); glutcreatewindow ("Z-bufor"); glutdisplayfunc (Display); glutreshapefunc (Reshape); glutspecialfunc (SpecialKeys); glutmainloop (); return 0; GenerateListLas(); Reshape (glutget (GLUT_WINDOW_WIDTH),glutGet (GLUT_WINDOW_HEIGHT));