Programowanie układów graficznych

Transkrypt

1 Programowanie układów graficznych Autor: Aleksander Dawid Wykład + Labolatorium 1. OpenGL obsługa podstawowej funkcjonalności GPU 2. GLSL programowanie przetwornika wierzchołków i fragmentów 3. CUDA programowanie ogólnego przeznaczenia 4. OpenCL rozwiązanie niezależne od sprzętu. Aleksander Dawid rok 1

2 OpenGL Silicon Graphics (IRIS GL stacje graficzne) Biblioteka -przestrzeń 3D -rzutowanie -prymitywy graficzne -operacje na barwach HISTORIA powstaje wersja 1.0 specyfikacji OpenGL przenośnej między platformami. OpenGL Architecture Review Board (SG,HP,IBM) Aleksander Dawid rok 2

3 OpenGL wersja 1.1 tej biblioteki z wieloma poprawkami przyśpieszającymi wyświetlanie grafiki. OpenGL nie należy do języków opisu sceny. Scena tworzona jest w OpenGL z wielokątów poprzez wywoływanie odpowiednich procedur Języki programowania Pascal,C/C++,Visual Basic,Python,Java Aleksander Dawid rok 3

4 OpenGL (WINDOWS) OpenGL nie ma funkcji obsługujących operacje: -wejścia/wyjścia -interakcje z użytkownikiem -zarządzanie oknami. WINDOWS Wprowadzono w wersjach Win95 OSR2 WinNT 3.51/4.0 Obsługa okien w OpenGL - funkcje wiggle. Aleksander Dawid rok 4

5 OpenGL (AUX) Wywołania funkcji w OpenGL są zgodne z konwencją wywoływania funkcji w języku C. Biblioteki w systemie WIN32 glaux.lib - Auxiliary(pomocnicza)przenośna glaux.h przedrostek funkcji: aux opengl32.dll gl.h gl glu32.dll glu.h glu Aleksander Dawid rok 5

6 OpenGL (AUX) Biblioteka aux raczej jest pewną osnową dla wywoływania f. OpenGL. Zaletą jej jest to, że na każdej platformie wygląda ona tak samo. OpenGl32.dll właściwe wywołania OpenGL. Glu32.dll biblioteka pomocnicza rysowanie skomplikowanych obiektów cylindry, walce, NURBS. Aleksander Dawid rok 6

7 OpenGL (Typy danych) OpenGL w celu przenośności między platformami wprowadza swoje typy danych. Glbyte,Glshort,Glint,Glsize,Glfloat, Glclampf,Gldouble,Glclampd,Glubyte, Glboolean,Glushort, Gluint, Glenum, Glbitfield. glclamp - color amplitude Aleksander Dawid rok 7

8 OpenGL (Konwencje nazw) <Przedrostek biblioteki><rdzeń polecenia><opcjonalnie liczba argumentów><opcjonalnie typ argumentów> glcolor3f(...) gl - gl.h Color - nazwa 3f - 3 argumenty float. Aleksander Dawid rok 8

9 OpenGL (Biblioteka aux) Przewidziana jako wspomaganie dla OpenGL w postaci implementacji przenośnej między systemami. Podstawowe operacje inicjalizujace wej/wyj. Aleksander Dawid rok 9

10 OpenGL (kod aux) #include <windows.h> #include <gl\gl.h> #include <gl\glaux.h> void CALLBACK RenderScene(void) { glclearcolor(0.0f, 0.0f, 1.0f, 1.0f); glclear(gl_color_buffer_bit); glcolor3f(1.0f, 0.0f, 0.0f); glrectf(100.0f, 150.0f, 150.0f, 100.0f); glflush(); } void main(void) { auxinitdisplaymode(aux_single AUX_RGBA); auxinitposition(100,100,450,450); auxinitwindow("test2"); auxmainloop(renderscene); } Aleksander Dawid rok 10

11 OpenGL (kod aux) auxinitdisplaymode(aux_single AUX_RGBA); Tryb wyświetlania: AUX_SINGLE - pojedynczy bufor AUX_RGBA - tryb kolorów. auxinitposition(100,100,450,450); Pozycja i wymiary okna. auxinitwindow("test2"); Nazwa okna auxmainloop(renderscene); Główna pętla renderowania obrazu. Aleksander Dawid rok 11

12 OpenGL (kod aux) glclearcolor(0.0f, 0.0f, 1.0f, 1.0f); Kolor używany do czyszczenia ekranu. Krok koloru glclear(gl_color_buffer_bit); Wykonanie czyszczenia ekranu. glcolor3f(1.0f, 0.0f, 0.0f); kolor rysowania. glrectf(100.0f, 150.0f, 150.0f, 100.0f); rysujemy prostokąt. Aleksander Dawid rok 12

13 OpenGL (kod aux) glflush(); Przetwarzaj dotychczasowe komendy. Nagłówki #include <windows.h> #include <gl\gl.h> #include <gl\glaux.h> Aleksander Dawid rok 13

14 Skalowanie okna wyświetlania. Nasz rysunek jest w rzeczywistości w przestrzeni 3D z=0. Przy zmianie wymiarów okna wyświetlania nasz obrazek też powinien być odpowiednio przeskalowany. Do tego służy funkcja auxreshapefunc(far* func), gdzie argumentem jest funkcja zwrotna o następującym prototypie. void CALLBACK ChangeSize(Glsizei w, Glsizei h) funkcja ta otrzymuje wysokość i szerokość z okna macierzystego przy każdej próbie przeskalowania go. Aleksander Dawid rok 14

15 Skalowanie okna wyświetlania. Możemy użyć tego do odwzorowania naszego układu współrzędnych na układ współrzędnych ekranu za pomocą funkcji; DEFINIOWANIE WIDOKU glviewport(glint x,glint y, Glint w, Glint h); x,y - prawy dolny róg widoku w,h - szerokość, wysokość Aleksander Dawid rok 15

16 Skalowanie okna wyświetlania. DEFINIOWANIE BRYŁY OBCINANIA Po zmianie rozmiaru okna musimy przedefniować bryłę obcinania aby stosunki współrzędnych zostały takie same. Stosunek współrzędnych (aspect ratio) to stosunek ilości pixeli odpowiadający jednostce osi pionowej do ilości pikseli na osi poziomej. 1.0 równe ilości pikseli na osiach. Rzutowanie równoległe glortho(gldouble lewa, Gldouble prawa, GLdouble dolna, GLdouble górna, Gldouble blizsza, Gldouble dalsza); Aleksander Dawid rok 16

17 Skalowanie okna wyświetlania. DEFINIOWANIE BRYŁY OBCINANIA glloadidentity(); - macierz jdnostkowa. glortho() modyfikuje istniejące obcinanie. Void CALLBACK ChangeSize(Glsizei w, Glsizei h){ if(h==0) h=1; glviewport(0,0,w,h); glloadidentity(); if(w<=h) glortho(0.0f, 250.0f, 0.0f, 250.0f*h/w, 1.0,-1.0); else glortho(0.0f, 250.0f*w/h, 0.0f, 250.0f, 1.0,-1.0); } auxreshapefunc(changesize); Aleksander Dawid rok 17

18 Animacje. Animacje w bibliotece pomocniczej osiągamy przez funkcje; auxidlefunction() gdzie argumentem jest funkcja o prototypie void CALLBACK IdleFunction(void); Funkcja jest wywoływana w momencie bezczynności programu. Nie jest wywoływana w momencie skalowania okna. Z animacją wiąże się problem wyświetlania. Najczęściej wyświetlanie nie nadąża za procesem rysowania co przejawiać się może w miganiu rysowanego obiektu. Aleksander Dawid rok 18

19 Animacje. W celu uniknięcia takiego zjawiska stosuje się podwójne buforowanie. Obraz naszej sceny nie jest rysowany na bufor ekranu tylko do pomocniczego bufora, a z niego dopiero a ekran. auxdisplaymode(aux_double,aux_rgba) auxswapbuffers(); Aleksander Dawid rok 19

20 Klawiatura. Biblioteka AUX pozwala nam modyfikować naszą scenę przez klawisze. auxkeyfunc(glint key, void(*func()); void CALLBACK KeyFunc(void); AUX_ESCAPE AUX_SPACE AUX_LEFT AUX_RIGHT AUX_UP AUX_DOWN Aleksander Dawid rok 20

21 Mysz. Biblioteka AUX pozwala nam na interakcje z naszą sceną prze mysz. auxmousefunc(glint button, Glint mode void(* MouseFunc()); PROTOTYP void CALLBACK MouseFunc(AUX_EVENTREC *event); typedef struct _AUX_EVENTREC{ GLint event; Glint data[4]; }AUX_EVENTREC event - AUX_MOUSEUP,AUX_MOUSEDOWN data[aux_mousex]=pozioma współrzędna myszy data[aux_mousey]=pionowa współrzędna myszy data[mouse_status]=przycisk myszy (button param) Aleksander Dawid rok 21

22 OpenGL (kod glut) Nagłówki #include <windows.h> #include <gl\gl.h> #include <gl\glut.h> int main(int argc, char **argv) { glutinit(&argc, argv); // GLUT inicjalizacja glutinitdisplaymode(glut_rgb GLUT_DOUBLE GLUT_DEPTH ); // Wyświetlanie glutinitwindowsize(640,480);// rozmiar okna glutcreatewindow("opengl/glut Window.");// utworzenie Okna glutdisplayfunc(display);// Wyświetlenie funkcji glutidlefunc( display );// Wyświetlanie w fazie bezczynności (Animacje) glutkeyboardfunc( keyboard );// Obsługa klawiszy glutmainloop();// główna pętla GLUT return 0; } Aleksander Dawid rok 22

23 Prymitywy graficzne. (2) Rysowanie w 3 wymiarach. Układ współrzędnych określa nam bryła obcinania (glortho). (-100,100) 1. Trójwymiarowy punkt: wierzchołek glvertex2f(10.0f, 10.0f); glvertex3f(10.0f, 10.0f, 0.0f); glvertex4f(10.0f, 10.0f, 0.0f, 1.0f); w - współczynnik skalowania. Aleksander Dawid rok 23

24 Prymitywy graficzne. Teraz mamy wierzchołek, wystarczy nam teraz określić czy ten wierzchołek będzie punktem, wierzchołkiem odcinka czy też jakiegoś wieloboku. Zadania wierzchołków grupujemy w pętli. glbegin(glenum mode)... glend() Zestaw punktów w 3D. glbegin(gl_points); glvertex3f(10.0f, 10.0f, 0.0f); glvertex3f(10.0f, 1.0f, 0.0f); glend(); Aleksander Dawid rok 24

25 Prymitywy graficzne. Pamiętać trzeba o tym że punkt jest rysowany aktualnie wybranym kolorem. W pętli glbegin/glend można zawrzeć dowolną liczbę prymitywów. Ponawianie ustawiania prymitywu powoduje spowolnienie całego procesu tworzenia grafiki. glbegin(gl_points); for(i=0;i<10;i++) { x+=0.1; y+=0.1; glvertex3f(x,y,0.0f); } glend(); Aleksander Dawid rok 25

26 Prymitywy graficzne. Ustalenie rozmiaru punktu. Domyślny rozmiar punktu to 1 pixel. Void glpointsize(glfloat size); size -średnica w pixelach rysowanego punktu. MS GL obsługuje wielkości od 0.05 do 10.0 co GLfloat sizes[2]; GLfloat step; glgetfloatv(gl_point_size_range,sizes); glgetflotav(gl_point_size_granularity,&step); Wywołania te dotyczą maszyny stanu OpenGL Aleksander Dawid rok 26

27 Prymitywy graficzne Rysowanie linii w 3 wymiarach. glbegin(gl_lines) glvertex3f(0.0,0.0,0.0); glvertex3f(50.0,50.0,50.0); glend(); Musimy podawać parzystą liczbę wierzchołków. Inaczej ostatni wierzchołek będzie ignorowany. Łamana GL_LINE_STRIP glbegin(gl_line_strip) glvertex3f(0.0,0.0,0.0); glvertex3f(50.0,50.0,50.0); glvertex3f(50.0,10.0,50.0); glend(); Aleksander Dawid rok 27

28 Prymitywy graficzne Łamana zamknięta GL_LINE_LOOP glbegin(gl_line_loop) glvertex3f(0.0,0.0,0.0); glvertex3f(50.0,50.0,50.0); glvertex3f(50.0,10.0,50.0); glend(); Po napotkaniu ostatniego punktu krzywa jest zamykana. Ustalenie grubości linii. gllinewidth(glfloat width) Informacje o szerokości możemy uzyskać z maszyny stanu OpenGL. Aleksander Dawid rok 28

29 Prymitywy graficzne glgetfloatv(gl_line_width_range,sizes); glgetfloatv(gl_line_width_ggranularity,&size); Linie przerywane. glenable(gl_line_stipple); gllinestipple(glint factor, Glushort pattern); Wyłączamy za pomocą gldisable(); pattern 16-bit = 0x00FF = 255; factor służy jako mnożnik zwiększający szerokość wzoru. Aleksander Dawid rok 29

30 Prymitywy graficzne Rysowanie wielokątów w przestrzeni 3D. Trójkąt. glbegin(gl_triangles) glvertex3f(0.0,0.0,0.0); glvertex3f(25.0,25.0,0.0); glvertex3f(50.0,0.0,0.0); glend(); Kolejność określa nam kierunek rysowanego trójkąta. Zgodnie ze wskazówkami zegara lub przeciwnie. OpenGL zakłada, że wielokąty skierowane przeciwnie do wskazówek zegara są do nas zwrócone przodem. Jeśli chcesz to zmienić to glfrontface(gl_cw); GL_CCW Aleksander Dawid rok 30

31 Prymitywy graficzne Rysowanie paska trójkątów. GL_TRIANGLE_STRIP Ilość wierzchołków może być większa od 3. Kolejność wierzchołków nie jest zachowana. Anticlockvise - kierunek przeciwny do wskazówek zegara musi być zachowany. Wachlarze trójkątów. GL_TRIANGLE_FAN Opcja ta służy do tworzenia zbioru trójkątów o wspólnym punkcie. Pierwszy wierzchołek wyznacza wspólny punkt dla wachlarza trójkątów. Aleksander Dawid rok 31

32 Prymitywy graficzne (jednolite obiekty) Prze tworzeniu złożonych obiektów musimy się zastanowić nad tym jaki jest nasz obiekt. O kolorze wielokąta decyduje pirwszy wierzchołek w wielokącie, przy modelu w którym kolor jest jednolity. Wybór modelu koloru. glshademodel(gl_flat); - jednolity kolor glshademodel(gl_smooth); - interpolacja kolorów pośrednich. glbegin(gl_triangles) glcolor3f(1.0f,0.0f,0.0f); glvertex3f(0.0,0.0,0.0); glvertex3f(25.0,25.0,0.0); glvertex3f(50.0,0.0,0.0); glend(); Aleksander Dawid rok 32

33 Prymitywy graficzne (bufor głębokości) W OpenGL obiekt rysowany jako drugi zawsze przesłania obiekt pierwszy. Problem ten można usunąć dzięki technice zwanej buforem głębokości. glenable(gl_depth_test); Testowane są pixele aby wyznaczyć te które są bliżej od tych które są dalej. W celu poprawy wydajności programu stosuje się nie rysowanie tylnych powierzchni. Aleksander Dawid rok 33

34 Prymitywy graficzne (usuwanie niewidocznych). Eliminacja wielokątów skierowanych tyłem nazywa się usuwaniem niewidocznych powierzchni. glenable(gl_cull_face); Wielokąty mogą być rysowane jako siatki lub wypełnione. glpolygonmode(gl_front_and_back,gl_line); glpolygonmode(gl_back,gl_fill); Można to ustawiać zarówno dla tyłu jak i przodu. Aleksander Dawid rok 34

35 Prymitywy graficzne (usuwanie niewidocznych) Czworokąty. GL_QUADS GL_QUAD_STRIP - pasek wielokątów. Ogólne wielokąty. GL_POLYGON może być używany do rysowania wielokąta o dowolnej liczbie krawędzi. Wypełnianie jednolitych wielokątów. Mapowanie tekstur. Określanie desenia. glenable(gl_polygon_stipple); glpolygonstipple(pbitmap); Aleksander Dawid rok 35

36 Prymitywy graficzne (desenie) Wskaźnik do obszaru danych zawierający dane desenia. Glubyte *pbitmap; pbitmap=new Glubyte[16] 32bit x 32bit delete[] pbitmap; Warunki konstruowania wielokątów to 1. Nie wolno produkować wygiętych wielokątów. 2. Tylko wielokąty wypukłe. Aleksander Dawid rok 36

37 Prymitywy graficzne (krawędzie). Figury wklęsłe można także konstruować w OpenGl składając je z kilku figur wypukłych. Gdy chcemy zachować krawędzie zewnętrzne jako widoczne to wystarczy podać czy ta krawędź należeć będzie do krawędzi zewnętrznych czy też nie. gledgeflag(true/false); glvertex2f(-20.0f,0.0f); Aleksander Dawid rok 37

38 Przekształcenia w 3D Umożliwiają rzutowanie trójwymiarowych współrzędnych na dwuwymiarowy ekran. Najpierw musimy określić położenie obserwatora. Są to bezwzględne współrzędne ekranowe. Przekształcenie punktu obserwacji. Odpowiada ustawieniu i skierowaniu kamery na scenę. Przekształcenie modelu. Aleksander Dawid rok 38

39 Przekształcenia w 3D (rzutowanie) Rzutowanie definiuje bryłę widzenia i definiuje bryłę obcinania. Równoległe glortho(..) równoległa bryła rzutowania Perspektywiczne Ostrosłup widzenia w kierunku oka. glfrustum(gldouble left,right,bottom,top,near,far) - mnoży bieżącą macierz przez macierz rzutowania perspektywicznego. Aleksander Dawid rok 39

40 Przekształcenia w 3D (rzutowanie) Znacznie lepszym rozwiązaniem jest funkcja void gluperspective(gldouble fovy, Gldouble aspect, Gldouble znear, Gldouble zfar) fovy - kąt pola widzenia w kierunku pionowym. Aspect - stosunek wysokości do szerokości bryły znear,zfar - odległości od bliższej i dalszej płaszczyzny. Dodatkowo co nam oferuje utility to funkcja glulookat(okox,okoy,okoz,punktx,punkty,punktz, gorax,goray,goraz); Pozwala ona na umieszczenie oka kamery w dowolnym punkcie. Aleksander Dawid rok 40

41 Przekształcenia w 3D (rzutowanie) Rzutowanie definiuje bryłę widzenia i definiuje bryłę obcinania. Macierz widoku modelu 4x4 V*M=V Translacje. void gltranslatef(glfloat x, Glfloat y, Glfloat z) gltranslatef(0.0,10.0,0.0); Aleksander Dawid rok 41

42 Przekształcenia w 3D (rzutowanie) Obroty. glrotatef(glfloat angle, Glfloat x, Glfloat y, Glfloat z); Kierunek obrotu jest określany w stopniach. Skalowanie. glscalef(glfloat x, Glfloat y, Glfloat z); Ściskanie i rozciąganie. Aleksander Dawid rok 42

43 Przekształcenia w 3D (rzutowanie) Macierz tożsamościowa(jednostkowa). glmatrixmode(gl_modelview) Macierz modelu widoku. glloadidentity(); Ładuje macierz tożsamościową do bierzącej macierzy. Stos macierzy. Maksymalna wysokość stosu. glget(gl_max_model_view_stack_depth); glget(gl_max_projection_stack_depth); GL_STACK_OVERFLOW - przepełnienie stosu GL_STACK_UNDERFLOW - zdejmowanie ze stosu pustego. Aleksander Dawid rok 43

44 Przekształcenia w 3D (rzutowanie) glpushmatrix(); Rotacje,translacje. glpopmatrix(); Własne macierze transformacji. Glfloat m[]={1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f} glmatrixmode(gl_modelview) glloadmatrix(m) // ładowanie macierzy jako bieżącej. glmatrixmode(gl_modelview) glmultmatrixf(m); // mnożenie macierzy Aleksander Dawid rok 44

45 Kolory w OpenGL Dwie metody RGBA i color index. RGBA (red,green,blue,alpha) Color index wybrane kolory z większej palety glcolor4f(1.0f,1.0f,0.0f,1.0f); glcolori(12); Aleksander Dawid rok 45

46 Światła w scenie (fotorealizm) (3) Światła: - otoczenia (ambient light) - rozproszone (diffuse) - odbłyski (specular) Światła w naszej scenie obliczamy załączając glenable(gl_lighting); Samo załączenie nic nie daje, trzeba jeszcze określić model oświetlenia. Bez tego nasz obiekt jest 2-wymiarowy. Najpierw określamy światło otoczenia. Glfloat ambient[] = {1.0f,1.0f,1.0f,1.0f} gllightmodelfv(gl_light_model_ambient,ambient); Aleksander Dawid rok 46

47 Światła w scenie (fotorealizm) Właściwości materiałów. Nasze wielokąty muszą odbijać światło. Glfloat green[]={0.0f,0.75f,0.0f,1.0f); glmaterialfv(gl_front, GL_AMBIENT_AND_DIFFUSE, green); Przy załączonym oświetleniu tylko w ten sposób można określić kolor naszego trójkąta. glbegin(gl_triangles);... glend(); Aleksander Dawid rok 47

48 Światła w scenie (fotorealizm) Generalnie teraz nie widać różnicy w naszej scenie. Faktyczna siła świateł tkwi w rozpraszaniu i odbłyskach. Właściwości materiału można określać dla przedniej lub tylnej ściany. GL_FRONT, GL_BACK, GL_FRONT_AND_BACK Inna metoda to śledzenie kolorów z użyciem glcolor jako funkcji określającej kolor. glenable(gl_color_material); glcolormaterial(gl_front, GL_AMBIENT_AND_DIFFUSE); Aleksander Dawid rok 48

49 Światła w scenie (fotorealizm) Do bardziej realistycznych scen potrzebne nam są światła umiejscowione. Źródła te posiadają położenia, intensywności, kolory jak i kierunek padania. Aby biblioteka wiedziała jak mocno rozświetlić daną płaszczyznę potrzebuje aby został określony wektor normalny do płaszczyzny naszego wielokąta. Aleksander Dawid rok 49

50 Wektor normalny Mając trzy punkty w przestrzeni możemy obliczyć wektory określające przestrzeń 2D V1 i V2 następnie produkt V1 x V2 da nam wektor prostopadły do naszej płaszczyzny. b a c Aleksander Dawid rok 50

51 Wektor normalny void ReduceToUnit(float vector[3]) { float length; // Calculate the length of the vector length = (float)sqrt((vector[0]*vector[0]) + (vector[1]*vector[1]) + (vector[2]*vector[2])); if(length == 0.0f) length = 1.0f; vector[0] /= length; vector[1] /= length; vector[2] /= length; } Aleksander Dawid rok 51

52 Wektor normalny void NormV(GLfloat va[3], GLfloat vb[3], GLfloat vc[3], GLfloat out[3]) { float v1[3],v2[3]; static const int x = 0, y=1, z=2; v1[x] = vb[x] - va[x]; v1[y] = vb[y] - va[y]; v1[z] = vb[z] - va[z]; v2[x] = vc[x] - va[x]; v2[y] = vc[y] - va[y]; v2[z] = vc[z] - va[z]; out[x] = v1[y]*v2[z] - v1[z]*v2[y]; out[y] = v1[z]*v2[x] - v1[x]*v2[z]; out[z] = v1[x]*v2[y] - v1[y]*v2[x]; ReduceToUnit(out); } Aleksander Dawid rok 52

53 Wektor normalny OpenGL Kąt obserwatora - kąt między wektorem normalnym a promieniem padania światła zrzutowany na płaszczyznę widzenia Kąt obserwatora jest miarą jasności danego wielokąta Glfloat va[3] = {40.0f,0.0f,0.0f}; Glfloat vb[3] = {0.0f,60.0f,0.0f}; Glfloat vc[3] = {-40.0f,0.0f,0.0f}; normlight[3]; NormV(va, vb, vc, normlight); glbegin(gl_trangle); glnormal3fv(&normlight); glvertex3fv(&va); glvertex3fv(&vb); glvertex3fv(&vc); glend(); Aleksander Dawid rok 53

54 Światła w scenie (fotorealizm) Przygotowanie źródła światła. Glfloat ambient[]={0.3,0.3,0.3,1.0f} Glfloat diffuse[]={0.7,0.7,0.7,1.0} gllightfv(gl_light0,gl_ambient,ambient); gllightfv(gl_light0,gl_diffuse,diffuse); Glfloat lpos[]={-50.0f,50.0f,100.0f,1.0f} gllightfv(gl_light0,gl_position,lpos); glenable(gl_light0); Do ustalenia koloru możemy także użyć funkcji glrgb(0,255,0); Aleksander Dawid rok 54

55 Światła w scenie (fotorealizm) Przygotowanie źródła światła. Glfloat specular[]={1.0,1.0,1.0,1.0f} gllightfv(gl_light0,gl_specular,specular); Ostatnia linia definiuje światło jasno białe dla odbłysków. STOPIEŃ POŁYSKLIWOŚCI. glmateriali(gl_front,gl_shininess,128); Określa jak mała i skupiona będzie plama połysku. Aleksander Dawid rok 55

56 Światła w scenie (fotorealizm) Domyślnie światło rozchodzi się w każdym kierunku. W celu przeniesienia światła do nieskończoności trzeba w ostatnim elemencie dać wartość zero. Światło punktowe załączamy przez gllightf(gl_light0,gl_spot_cutof,60.0f); gllightf(gl_light0,gl_spot_exponent,100.0f); glpushattrib(gl_lighting_bit); Instrukcja zachowuje stan oświetlenia. glpopattrib(); Przywraca pierwotny stan oświetlenia. Aleksander Dawid rok 56

57 Cienie (fotorealizm) Tworzenie cieni nie jest zaimplementowane w OpenGL bezpośrednio. Cienie można stworzyć programowo na kilka sposobów. Na podstawie równania płaszczyzny i położenia światła tworzy się macierz rzutu cienia. Macierz ta jest zwykłą macierzą rzutowania perspektywicznego, z tą różnicą, że punktem położenia obserwatora jest tutaj położenie źródła światła. Jeśli tę macierz będziemy mnożyć przez macierz widoku modelu, to obiekty będą spłaszczane na tę płaszczyznę Aleksander Dawid rok 57

58 Cienie (fotorealizm) // Procedura tworząca macierz rzutu cienia. void MakeShadowMatrix(GLfloat points[3][3], GLfloat lightpos[4], GLfloat destmat[4][4]) { GLfloat planecoeff[4]; GLfloat dot; // Znalezienie współczynników równania płaszczyzny // Wyszukanie trzech pierwszych współczynników tak samo // jak przy znajdowaniu normalnej calcnormal(points,planecoeff); // Znalezienie ostatniego współczynnika przez zastępowanie wstecz planecoeff[3] = - ( (planecoeff[0]*points[2][0]) + (planecoeff[1]*points[2][1]) + (planecoeff[2]*points[2][2])); Aleksander Dawid rok 58

59 Cienie (fotorealizm) // Iloczyn skalarny płaszczyzny i położenia światła dot = planecoeff[0] * lightpos[0] + planecoeff[1] * lightpos[1] + planecoeff[2] * lightpos[2] + planecoeff[3] * lightpos[3]; // A teraz rzutowanie // Pierwsza kolumna destmat[0][0] = dot - lightpos[0] * planecoeff[0]; destmat[1][0] = 0.0f - lightpos[0] * planecoeff[1]; destmat[2][0] = 0.0f - lightpos[0] * planecoeff[2]; destmat[3][0] = 0.0f - lightpos[0] * planecoeff[3]; // Druga kolumna destmat[0][1] = 0.0f - lightpos[1] * planecoeff[0]; destmat[1][1] = dot - lightpos[1] * planecoeff[1]; destmat[2][1] = 0.0f - lightpos[1] * planecoeff[2]; destmat[3][1] = 0.0f - lightpos[1] * planecoeff[3]; Aleksander Dawid rok 59

60 Cienie (fotorealizm) // Trzecia kolumna destmat[0][2] = 0.0f - lightpos[2] * planecoeff[0]; destmat[1][2] = 0.0f - lightpos[2] * planecoeff[1]; destmat[2][2] = dot - lightpos[2] * planecoeff[2]; destmat[3][2] = 0.0f - lightpos[2] * planecoeff[3]; } // Czwarta kolumna destmat[0][3] = 0.0f - lightpos[3] * planecoeff[0]; destmat[1][3] = 0.0f - lightpos[3] * planecoeff[1]; destmat[2][3] = 0.0f - lightpos[3] * planecoeff[2]; destmat[3][3] = dot - lightpos[3] * planecoeff[3]; Program shadows.c Aleksander Dawid rok 60

61 Listy wyświetalania Listy wyświetlania przyspieszają wykonywanie programu OpenGL w przypadku dużej liczby wielokątów. PROCEDURA glnewlist(1, GL_COMPILE);... Kod OpenGL glendlist(); Następnie wywołanie tak przygotowanej listy wygląda następująco glcalllist(1); Zamiast 1 można zasosować dowolny identyfikator Gluint list Aleksander Dawid rok 61

62 Grafika rastrowa BITMAPY. Obrazki 2 - kolorowe. Kolor 0 - przezroczysty 1 - bieżący. Do rysowania bitmap służy funkcja glbitmap glbitmap(glsizei width,glsizei height, Glfloat xorig,glfloat yorig,glfloat xmove, Glfloat ymove,const Glubyte *bits) xorig,yorig - położenie środka xmove,ymove - przesunięcie w bitmapie. Do ustalenia pozycji obrazka na naszym oknie służy. glrasterpos2i(x,y); Aleksander Dawid rok 62

63 Grafika rastrowa CZCIONKI BITMAPOWE. Aby w OpenGL wyświetlić jakieś teksty na ekranie trzeba przygotować odpowiedni zestaw czcionek. Gluint base; HDC hdc; base=glgenlists(96); wglusefontbitmaps(hdc,32,96,base); Tworzy 96 bitmap znaków poczynając od kodu 32 gllistbase(font-32); glcalllists(strlen(s), GL_UNSIGNED_BYTE, s); Aleksander Dawid rok 63

64 Grafika rastrowa Funkcja gllistbase ustawia wartość bazową list wyświetlania. glcalllists - wyświetla nam nasze czcionki wg. zadanego tekstu. Czcionkę możemy ustawić funkcjami Win32 font=createfont(...) SelectObject(hdc,font); Aleksander Dawid rok 64

65 Grafika rastrowa. PIXMAPY Obrazy zawierające więcej niż 2 kolory nazywamy pixmapami. Do rysowania pixmap służy funkcja gldrawpixels(glsizei width, Glsizei height, Glenum format, Glenum type, Glvoid *pixels) format GL_COLOR_INDEX GL_RGB GL_LUMINANCE type GL_BYTE GL_UNSIGNED_BYTE GL_BITMAP Aleksander Dawid rok 65

66 Grafika rastrowa REMAPOWANIE KOLORÓW glpixeltransfer(gl_red_scale, 1.1); glpixeltransfer(gl_green_scale, 1.1); glpixeltransfer(gl_blue_scale, 1.1); Kod rozjaśnia obraz RGB o 10% SKALOWANIE PIXMAP glpixelzoom(1.0,1.0);brak skalowania glpixelzoom(-1.0,1.0);odbicie lustrzane w poziomie glpixelzoom(0.2,0.2);zmniejszenie obrazka Aleksander Dawid rok 66

67 Grafika rastrowa WYKRAWANIE OBSZARÓW glpixelstore(gl_unpack_row_lenght, 640); glpixelstore(gl_unpack_skip_pixels, 100); glpixelstore(gl_unpack_skip_rows, 100); gldrawpixels(300,300,gl_rgb,gl_unsigned_byte,bi tmapbits); ODCZYTYWANIE PIXMAP Z EKRANU glreadpixels(glint x,glint y,glsizei width Glsizei height, Glenum format, Glenum type, const Glvoid *pixels); Aleksander Dawid rok 67

68 Mapowanie tekstur Nakładanie obrazów na wielokąty w scenie. Akceleratory 3D same mapują tekstury. Definiowanie textur 1D glteximage1d(glenum target,glint level,glint components,glsizei width, Glint border, Glenum format, Glenum type, const Glvoid *pixels); target - określa jaka tekstura powinna być zdefiniowana (GL_TEXTURE_1D) level - poziom szczegółów obrazu zwykle 0 jak nie ma mipmapy. Components - okresla ilosc wartosci koloru dla jednego pixela RGB=3, RGBA=4 Aleksander Dawid rok 68

69 Mapowanie tekstur Width - długość ciągu pixeli musi stanowić potęgę 2. border - pixle ramki format - określa w jakim formacie zapisane są kolory (GL_COLOR_INDEX, GL_RGB, GL_RGBA, GL_LUMINANCE); FILTRY POWIĘKSZENIA I POMNIEJSZENIA. gltexparameteri(gl_texture_1d, GL_TEXTURE_MIN_FILTER,GL_LNEAR); gltexparameteri(gl_texture_1d,gl_texture_mag_filter,gl_lnear); GL_NEAREST,GL_LINEAR, GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR - liniowo interpolowana mipmapa GL_LINEAR_MIPMAP_LINEAR - liniowo interpolacja interpolowanych mipmap. GL_NEAREST - najlepsza wydajnosc. Aleksander Dawid rok 69

70 Mapowanie tekstur Definiowanie textur 2D glteximage2d(glenum target,glint level, Glint components, Glsizei width, Glsizei height, Glint border, Glenum format, Glenum type, const Glvoid *pixels) Dodany jedynie height czyli wysokość mapowanego obrazka. width i height muszą być rozmiaru potęg liczby 2 2,4,8,16,32,64,128,256,512,1024 Aleksander Dawid rok 70

71 Mapowanie tekstur Rysowanie wielokątów z nałożoną teksturą. Teksturowanie trzeba załączyć glenable(gl_texture_nd); gltexenvi(gl_texture_env,gl_texture_env_mode, GL_DECAL); Ustawienie teksturowania w tryb kafelków. GL_MODULATE - piksele tekstury filtrują kolory istniejących pikseli na ekranie GL_DECAL GL_BLEND - łączenie ze stałym kolorem. Symulacja chmur. Aleksander Dawid rok 71

72 Mapowanie tekstur MIPMAPY Pozwalają zastosować zmienny poziom szczegółów w zależności od odległości od obserwatora. Użycie mniejszych obrazków zwiększa wiarygodność sceny jak i wydajność kodu. Wprowadzamy mipmapy przez funkcje glteximagend podając level i odpowiadającą mu mapę. glteximage2d(gl_texture_2d,0,3,128,128,gl_rgb,gl_unsigned_byte, imagebits0); glteximage2d(gl_texture_2d,1,3,128,128,gl_rgb,gl_unsigned_byte, imagebits1); GL_LINEAR_MIPMAP_LINEAR; Aleksander Dawid rok 72

73 Przykładowy Program mapowanie tekstur GLvoid PolygonTex(GLvoid) { GLfloat s=1.0f; glenable(gl_texture_2d); gltexenvi(gl_texture_env, GL_TEXTURE_ENV_MODE, GL_DECAL); glcalllist(walltexture); } glbegin(gl_polygon); gltexcoord2f(0.0, 0.0); glvertex3f(-4.0,-1.0,1.0); gltexcoord2f(s, 0.0); glvertex3f(4.0,-1.0,1.0); gltexcoord2f(s, s); glvertex3f(4.0,-1.0,-5.0); gltexcoord2f(0.0, s); glvertex3f(-4.0,-1.0,-5.0); glend(); Aleksander Dawid rok 73

74 Kwadryki (4) GLU32.DLL biblioteka utility OpenGL W niej zdefiniowane są proste kształty 3D takie jak cylindry,sfery,walce,dyski,powierzchnie. GLUquadricObj *quadobj; Struktura danych w której przechowywane są informacje na temat wierzchołków, normalnych, współrzędnych tekstur, sposobu łączenia wierzchołków i wiele innych. Dostęp do tych parametrów zapewniają odpowiednie funkcje. quadobj = glunewquadric(); Instrukcja tworzy nowy obiekt quadobj gludeletequadric (quadobj); Instrukcja niszczy obiekt quadobj i zwalnia pamięć gluquadriccallback (quadobj, GLenum which, void (*fn)()); fn funkcja kontrolna wywoływana w przypadku błędów. Aleksander Dawid rok 74

75 Kwadryki gluquadricorientation(quadobj,glu_outside); Kontrola kierunku wektorów normalnych GLU_OUTSIDE na zewnątrz figury GLU_INSIDE do wnętrza figury gluquadricnormals (quadobj, GLU_SMOOTH); Definiuje wektory normalne. GLU_NONE - wartość domyślna, brak wektorów normalnych, stosowana przy braku oświetlenia. GLU_FLAT generowanie wektorów normalnych dla każdej powierzchni, stosowane w przypadku cieniowania. GLU_SMOOTH generowani wektorów normalnych dla każdego wierzchołka, najlepsza jakość przy oświetleniu. Aleksander Dawid rok 75

76 Kwadryki gluquadricdrawstyle (quadobj, GLU_LINE); Ustawia styl renderowania obiektów. GLU_POINT wierzchołki przedstawiane jako punkty. GLU_LINE wierzchołki połączone liniami, model szkieletowy. GLU_SILHOUETTE wierzchołki połączone liniami, stosowane w dyskach. GLU_FILL wypełnione wielokąty, rysowane zgodnie z kierunkiem wskazywanym przez wektory normalne. gluquadrictexture (quadobj, GLU_TRUE); Funkcja odpowiedzialna za generowanie współrzędnych tekstury GLU_FALSE Wartość domyślna, brak generowania współrzędnych tekstury. GLU_TRUE Załączone generowanie współrzędnych tekstury, zależne od typu obiekty kwadryki. Aleksander Dawid rok 76

77 Kwadryki - prymitywy glusphere(quadobj, radius, gridalfa, gridgama); radius - promień sfery gridalfa - rozdzielczość elementów pozioma gridgama - rozdzielczość elementów pionowa glucylinder(quadobj,rbase,rtop,height,slices,stacks); Rbase - promień podstawy Rtop - promień wierzchołka Height - wyskość slices,stacks - określają z ilu elementów składa się obiekt. gludisk(quadobj,rinner,router,slices,loops); Rinner - promień wewnętrznego dysku. Router - promień zewnętrznego dysku. slices,loops - określają z ilu elementów składa się obiekt. Aleksander Dawid rok 77

78 Kwadryki - prymitywy glupartialdisk(quadobj,rinner,router,slices,loops,starta ngle, sweepangle); Rinner - promień wewnętrznego dysku Router - promień zewnętrznego dysku slices,loops - określają z ilu elementów składa się obiekt startangle kąt startowy sweepangle kąt częściowego dysku Aleksander Dawid rok 78

79 Kwadryki - program GLvoid RenderQuadrics() { glenable(gl_lighting); glshademodel (GL_SMOOTH); gltranslatef(-1.0, -1.0, 0.0); glcalllist(startlist); glshademodel (GL_FLAT); gltranslatef(0.0, 2.0, 0.0); glpushmatrix(); glrotatef(300.0, 1.0, 0.0, 0.0); glcalllist(startlist+1); glpopmatrix(); gldisable(gl_lighting); glcolor3f(0.0, 1.0, 1.0); gltranslatef(2.0, -2.0, 0.0); glcalllist(startlist+2); } glcolor3f(1.0, 1.0, 0.0); gltranslatef(0.0, 2.0, 0.0); glcalllist(startlist+3); Aleksander Dawid rok 79

80 Przezroczystość Przezroczystość (BLENDING). Polega na łączeniu kolorów czyli kontrolowaniu wartości RGBA poszczególnych pixeli. Wartość A odpowiada bezpośrednio za blending. Kolor źródłowy(r s,g s,b s,a s ) Kolor docelowy(r d,g d,b d,a d ) Czynniki przezroczystości źródła (S r,s g,s b,s a ) Czynniki przezroczystości docelowy (D r,d g,d b,d a ) Równanie przezroczystości (R s S r +R d D r, G s S g +G d D g, B s S b +B d D b, A s S a +A d D a ) glenable(gl_blend). Załączenie łączenia kolorów bieżącego z kolorem zeskładowanym w buforze ramki. gldisable(gl_blend) - wyłączenie obliczeń kolorów. Aleksander Dawid rok 80

81 Przezroczystość glblendfunc(gl_src_alpha,gl_one_minus_src_alpha); Parametry określają sposoby łączenia kolorów źródłowego i docelowego. Dla tych ustawień kolor alpha będzie określał przezroczystość. GL_ZERO źródło lub przeznaczenie (0, 0, 0, 0) GL_ONE źródło lub przeznaczenie (1, 1, 1, 1) GL_DST_COLOR źródło (Rd, Gd, Bd, Ad) GL_SRC_COLOR przeznaczenie (Rs, Gs, Bs, As) GL_ONE_MINUS_DST_COLOR źródło (1, 1, 1, 1)-(Rd, Gd, Bd, Ad) GL_ONE_MINUS_SRC_COLOR przeznaczenie (1, 1, 1, 1)-(Rs, Gs, Bs, As) GL_SRC_ALPHA źródło lub przeznaczenie (As, As, As, As) GL_ONE_MINUS_SRC_ALPHA źródło lub przeznaczenie (1, 1, 1, 1)-(As, As, As, As) GL_DST_ALPHA źródło lub przeznaczenie (Ad, Ad, Ad, Ad) GL_ONE_MINUS_DST_ALPHA źródło lub przeznaczenie (1, 1, 1, 1)-(Ad, Ad, Ad, Ad) GL_SRC_ALPHA_SATURATE źródło (f, f, f, 1); f=min(as, 1-Ad) Aleksander Dawid rok 81

82 Przezroczystość GLvoid drawscene(glvoid) { glclearcolor( 0.0F, 0.0F, 0.0F, 0.0F); glcleardepth( 1.0 ); glclear( GL_COLOR_BUFFER_BIT GL_DEPTH_BUFFER_BIT); if(x>2.0)x=0; x+=0.01; glpushmatrix(); drawrighttriangle(); glpopmatrix(); glpushmatrix(); gltranslatef(x,0.0f,0.0f); drawlefttriangle(); glpopmatrix(); } SWAPBUFFERS; GLvoid initializegl(glsizei width, GLsizei height) { glenable (GL_BLEND); glblendfunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glshademodel (GL_FLAT); glclearcolor( 0.0f, 0.0f, 0.0f, 0.0f); } Aleksander Dawid rok 82

83 Antialiasing Wygładzanie krawędzi krzywych Problem pojawia się gdy krzywe rysowane są pod dużym kątem, wtedy pojawiają się na krzywej schodki. Obraz bez antialiasingu Obraz z antialiasingiem Wygładzanie polega na dodaniu dodatkowych krzywych pokrywających. Realizacja tego zadania zależy od sterowników karty graficznej Aleksander Dawid rok 83

84 Antialiasing Jakość krzywych glhint(glenum target, GLenum hint) Hint: GL_FASTEST, GL_NICEST, GL_DONT_CARE Parametr GL_POINT_SMOOTH_HINT, GL_LINE_SMOOTH_HINT, GL_POLYGON_SMOOTH_HINT Znaczenie Określa jakość próbkowania dla punktów,linii, lub wielokątów podczas operacji antialiasingu GL_FOG_HINT GL_PERSPECTIVE_CORRECTION_ HINT Określa czy obliczenia dla mgły maja być wykonane dla piksla (GL_NICEST) lub dla wierzchołka (GL_FASTEST) Określa jakość danego koloru i interpolacji współrzędnych tekstury. Aleksander Dawid rok 84

85 Mgła Mgła (FOG). Dodanie efektu atmosferycznego czyli zależnego od głębokości cieniowania każdego elementu sceny polega na wymieszaniu pewnego koloru z każdym wierzchołkiem lub obiektem tekstury. glenable(gl_fog); Wybieramy rodzaj mgły. glfogi(gl_fog_mode, GL_LINEAR); GL_EXP,GL_EXP2 Wybieramy kolor mgły. GLfloat fogcolor[4] = {0.7F, 0.8F, 1.0F, 1.0F}; glfogfv (GL_FOG_COLOR, fogcolor); Aleksander Dawid rok 85

86 Mgła Mgła (FOG). Symuluje efekty atmosferyczne takie jak mgły, zadymienie, zanieczyszczenie środowiska. Pozwala obiektom dalekim płynnie znikać. Możemy kontrolować gęstość mgły jak i jej kolor. glfogf (GL_FOG_DENSITY, 0.005); glfogi(gl_fog_mode, GL_EXP); F=e -(density.z) (GL_EXP) F=e -(density.z)^2) (GL_EXP2) F=(end-z)/(end-start)(GL_LINEAR) glhint (GL_FOG_HINT, GL_DONT_CARE); Aleksander Dawid rok 86

87 Mgła GLfloat fogcolor[4] = {0.5, 0.5, 0.5, 1.0}; glfogi (GL_FOG_MODE, GL_EXP); glfogfv (GL_FOG_COLOR, fogcolor); glfogf (GL_FOG_DENSITY, 0.065f); glhint (GL_FOG_HINT, GL_DONT_CARE); glfogf (GL_FOG_START, 1.0); glfogf (GL_FOG_END, 5.0); Aleksander Dawid rok 87

88 Krzywe glmap1f(glenum target,glfloat u1,glfloat u2, GLint stride,glint order,const GLfloat *points) Funkcja rysuje krzywe Beziera na podstawie punktów kontrolnych. Target - typ. współrzędnych GL_MAP1_VERTEX_3 - wierzchołki (x, y, z). GL_MAP1_COLOR_4 - kolory punktów w postaci (r, g, b, a). GL_MAP1_TEXTURE_COORD_2 - współrzędne w obszarze tekstury (s, t). GL_MAP1_NORMAL - współrzędne wektora normalnego (nx, ny, nz). u1,u2 to dziedzina funkcji Stride - oznacza liczbę współrzędnych składających się na każdy punkt kontrolny order - liczba punktów kontrolnych Aleksander Dawid rok 88

89 Krzywe glenable(target); void glmapgrid1f(glint n, GLfloat u1, GLfloat u2) N określa ilość punktów krzywej do obiczeń, u1,u2 dziedzina void glevalmesh1(glenum mode, GLint p1, GLint p2) mode - GL_ POINTS, GL_LINE p1 i p2 oznaczają numery próbek, od których zaczynamy i na których kończymy obliczenia. Aleksander Dawid rok 89

90 Krzywe float fctrlpointsarray[4][3]= { {(0.0f/3.0f)*4.0f-2.0f,(1.0f)*4.0f-2.0f,0.0f}, {(1.0f/3.0f)*4.0f-2.0f,(3.0f/4.0f)*4.0f-2.0f,0.0f}, {(2.0f/3.0f)*4.0f-2.0f,(3.0f/5.0f)*4.0f-2.0f,0.0f}, {(3.0f/3.0f)*4.0f-2.0f,(1.0f/2.0f)*4.0f-2.0f,0.0f} }; void Init(void) { glclearcolor(0.0,0.0,0.0,0.0); glmap1f(gl_map1_vertex_3,0.0,1.0,3,4,&fctrlpointsarray[0][0]); glenable(gl_map1_vertex_3); glmapgrid1f(100,0.0,1.0); } void CALLBACK Display(void) { glclear(gl_color_buffer_bit); glcolor3f(1.0,1.0,1.0); glevalmesh1(gl_line,0,100); glpointsize(3.0); glcolor3f(1.0,0.0,0.0); glbegin(gl_points); for (i=0;i<4;i++) glvertex3fv(&fctrlpointsarray[i][0]); glend(); glflush(); } Aleksander Dawid rok 90

91 Powierzchnie void glmap2f(glenum target,glfloat u1,glfloat u2,glint ustride,glint uorder,glfloat v1, GLfloat v2,glint vstride,glint vorder,const GLfloat *points); MAP1 -> MAP2 void glmapgrid2f(glint nu, Glfloat u1, Glfloat u2, GLint nv, Glfloat v1, Glfloat v2) void glevalmesh2(glenum mode, GLint i1, GLint i2, GLint j1, GLint j2). Aleksander Dawid rok 91

92 Powierzchnie i Krzywe Przykłady f(x, y) = 1/[(x + 1) (y + 1)] glmap2f(gl_map2_vertex_3,0.0,1.0,3,4,0.0,1.0,1 2,4,&fCtrlPointsArray[0][0][0]); glmap2f(gl_map2_texture_coord_2,0.0,1.0,2,2,0. 0,1.0,4,2,&fTexCtrlPointsArray[0][0][0]); glenable(gl_map2_vertex_3); glenable(gl_map2_texture_coord_2); glmapgrid2f(100,0.0,1.0,100,0.0,1.0); Aleksander Dawid rok 92

93 Bufor głębokości Działanie bufora głębokości polega na przechowywaniu współrzędnej z dla każdego piksela obrazu. Podczas renderingu obliczana jest wartość współrzędnej z piksela obrazu i porównywana jest z wartością bufora głębokości. W ten sposób stwierdzane jest przesłanianie obiektów namalowanych wcześniej. Standardowo OpenGL nie wykonuje operacji na buforze głębokości Włączenie bufora głębokości glenable(gl_depth_test) Wyłączenie zapisu do bufora głębokości gldepthmask(glboolean flag) flag GL_TRUE, GL_FALSE Aleksander Dawid rok 93

94 Bufor głębokości Kontrola sposobu sprawdzania bufora głębokości gldepthfunc(glenum func) Wartości 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. Aleksander Dawid rok 94

95 Bufor głębokości 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. glcleardepth( GLclampd depth ) Standardowo bufor głębokości zawiera liczby z przedziału [0, 1] i jest czyszczony liczbą 1 Biblioteka OpenGL umożliwia zmianę tego przedziału poprzez użycie funkcji: gldepthrange( GLclampd znear, GLclampd zfar ) Aleksander Dawid rok 95

96 Bufor głębokości Przesunięcie wartości głębi W wersji 1.1 biblioteki OpenGL, a wcześniej w rozszerzeniu EXT polygon offset, wprowadzono mechanizm pozwalający na przesuwanie wartości głębi pikseli przy rysowaniu wielokątów. Przesunięcie wyliczane jest na podstawie wzoru: (m * factor) + (r * units) którego współczynnik m oznacza maksymalne nachylenie głębokości wielokąta (obliczenia wykonuje OpenGL), a współczynnik r jest zależną od implementacji najmniejszą różnicą wartości przechowywanych w buforze głębokości. Określenie wartości współczynników skalowania factor i units wymaga wywołania funkcji: glpolygonoffset( GLfloat factor, GLfloat units ) Przesuwanie wartości głębi jest domyślnie wyłączone. Włączenie tego mechanizmu wymaga wywołania funkcji glenable z jednym z poniższych 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. Aleksander Dawid rok 96

97 Bufor szablonowy (5) Stencil buffer Bufor dodatkowy (konfigurowalny), podobny do bufora głębokości. Składowany w nim jest szablon kolorów jako filtr. Bufor ten określa, które piksele ekranu mają ulegać zmianie, a które nie. Wartości w buforze szablonu przechowywane są dla każdego piksela. Ilość bitów na 1 piksel wacha się między 1 a 8. Przy 8bit rozdzielczości możemy nałożyć 256 warunków na wyświetlanie pikseli. Zastosowania Cienie (shadows) Lustra (mirrors) Filtry Aleksander Dawid rok 97

98 Bufor szablonowy Załączenie/Wyłączenie bufora glenable(gl_stencil_test); gldisable(gl_stencil_test); Czyszczenie bufora szablonowego glclear(gl_stencil_buffer_bit); Domyślnie bufor szablonowy wypełniany jest zerami, ale można to zmienić przy pomocy funkcji. glclearstancil(glint s);, gdzie s jest dowolna liczbą całkowitą Aleksander Dawid rok 98

99 Bufor szablonowy Sterowanie buforem szablonowym glstencilfunc( GLenum func, GLint ref, GLuint mask ) Dla parametru func mamy te same możliwości co dla bufora głębokości 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. Aleksander Dawid rok 99

100 Bufor szablonowy Parametr ref Parametr ref określa wartość referencyjną używaną w teście bufora szablonowego. Wartość ta jest zawsze obcinana do przedziału [0, 2n 1], gdzie n jest ilością bitów bufora szablonu. Parametr mask Określa maskę bitową dla których bitów wykonywany jest test porównania wartości referencyjnej z wartościami zeskładowanymi w buforze szablonu. Domyślna wartość maski bitowej dla bufora szablonu wynosi 1. Ustawienie te można zmienić przy pomocy funkcji glstencilmask(uint mask) Aleksander Dawid rok 100

101 Funkcja sterująca buforem Bufor szablonowy glstencilop(glenum sfail,glenum dpfail,glenum dppass) sfail, określa reakcję na negatywny wynik testu bufora szablonu dpfail, pozytywny wynik testu bufora szablonu, negatywny bufora głębokości dppass, pozytywny szablonu i głębokości Domyślna wartość dla wszystkich tych przypadków to GL_KEEP GL_KEEP - wartość bufora szablonowego nie jest zmieniana, GL_ZERO - wartość bufora szablonowego jest zerowana, GL_REPLACE - wartość bufora szablonowego jest zamieniana wartością referencyjną określoną w parametrze ref funkcji glstencilfunc, GL_INCR - wartość bufora szablonowego jest zwiększana o 1; w przypadku wystąpienia nadmiaru rezultat przyjmuje maksymalną wartość obsługiwaną przez bufor szablonowy, GL_DECR - wartość bufora szablonowego jest zmniejszana o 1; w przypadku wystąpienia niedomiaru rezultat przyjmuje wartość 0, GL_INVERT - wartość bufora szablonowego jest negowana, GL_DECR_WRAP - wartość bufora szablonowego jest zmniejszana o 1; w przypadku wystąpienia niedomiaru rezultat przyjmuje maksymalną wartość obsługiwaną przez bufor szablonowy, GL_INCR_WRAP - wartość bufora szablonowego jest zwiększana o 1; w przypadku wystąpienia nadmiaru rezultat przyjmuje wartość 0. Aleksander Dawid rok 101

102 Bufor szablonowy W OpenGL 2.0 wprowadzono wersje tych funkcji osobne dla przedniej GL_FRONT i tylnej GL_BACK wielokąta GL_FRONT 2 1 GL_BACK glstencilfuncseparate(enum face,enum func,int ref,uint mask ) glstencilopseparate(enum face,enum sfail,enum dpfail,enum dppass ) glstencilmaskseparate(enum face,uint mask) Aleksander Dawid rok 102

103 Bufor szablonowy Odbicie lustrzane gldisable(gl_stencil_test); glenable(gl_stencil_test); Aleksander Dawid rok 103

104 Bufor akumulacyjny Przechowuje informacje RGBA dla koloru, w trybie kolor indeks jest niedostępny. Zadania Łączenie kilku obrazów w celu uzyskania pożądanego efektu końcowego. Zastosowanie Efekt rozmycia podczas ruchu (ang. motion blur) Głębia ostrości (ang. depth of field) antyaliasing pełnoekranowy (ang. FSAA - Full Scene Anti Aliasing) miękkie cienie (ang. soft shadows) Aleksander Dawid rok 104

105 Sterowanie buforem Bufor akumulacyjny glaccum(glenum op,glfloat value) op określa rodzaj operacji wykonywanej na buforze value parametr operacji (R a,g a,b a,a a ) wektor bufora akumulacji (R c,g c,b c,a c ) wektor bufora kolorów Dostępne operacje op algebraiczne na buforze akumulacji GL_ACCUM R a = R a + value R c G a = G a + value G c B a = B a + value B c A a = A a + value A c Aleksander Dawid rok 105

106 Bufor akumulacyjny GL_LOAD GL_RETURN GL_MULT GL_ADD R a = value R c G a = value G c B a = value B c A a = value A c R c = value R a G c = value G a B c = value B a A c = value A a R a = value R a G a = value G a B a = value B a A a = value A a R a = R a + value G a = G a + value B a = B a + value A a = A a + value Aleksander Dawid rok 106

107 Bufor akumulacyjny Czyszczenie bufora akumlacyjnego glclear(gl_accum_buffer_bit) Domyślna wartość wypełnienia to wektor zerowy (0,0,0,0) Wartość tę można zmienić przez funkcję glclearaccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) Składowe kolorów w razie potrzeby obcinane są do przedziału [ 1, 1] Aleksander Dawid rok 107

108 Bufor akumulacyjny Rozmycie w ruchu // dodanie przeskalowanych wartości z bufora kolorów do bufora akumulacynego glaccum( GL_ACCUM, 0.1f ); // kopiowanie wartości z bufora akumulacyjnego do bufora kolorów glaccum( GL_RETURN, 1.0f ); // załadowanie przeskalowanych wartości z bufora kolorów do bufora akumulacyjnego glaccum( GL_LOAD, 0.9f ); Aleksander Dawid rok 108

109 GL Shading Language (GLSL) Wprowadzenie do programowania shaderów Aleksander Dawid rok 109

110 GL Shading Language (GLSL) Język shaderów wprowadzony został w celu oprogramowania tych elementów OpenGL, które miały ustaloną funkcjonalność. Dotyczy to przetwarzania wierzchołków i fragmentów. Fragment jest wynikiem rasteryzacji prymitywów składających się z wierzchołków kolorów i tekstur. Przetwarzanie fragmentów dotyczy takich operacji jak przycinanie, test alfa, test głębokości, test szablonu, mieszanie kolorów, mapowania tekstur i wiele innych. Shader niezależnie kompilowalna jednostka obliczeniowa Program to zestaw shaderów, skompilowanych i połączonych razem Aleksander Dawid rok 110

111 GL Shading Language (GLSL) Połączenia wierzchołków Wierzchołki Transformacja wierzchołków (vertex shader) Przetworzone wierzchołki Składanie prymitywów i rasteryzacja Położenia pikseli Fragmenty Odświeżenie pikseli Rasteryzacja Pokolorowane fragmenty Teksturowanie i kolorowanie fragmentów (pixel shader) Potok przetwarzania grafiki komputerowej Aleksander Dawid rok 111

112 GL Shading Language (GLSL) Procesor wierzchołków Na wejściu: położenia, kolor, normalne, współrzędne tekstury Ustalona funkcjonalność Transformacje pozycji wierzchołka Oświetlenie dla wierzchołka Generowanie i przekształcanie współrzędnych tekstur Składanie prymitywów i rasteryzacja Na wejściu: informacja o wierzchołkach i sposobie ich połączenia Na tym etapie wykonywane są również obliczenia związane z obcinanie względem bryły widoku oraz usuwane są niewidoczne powierzchnie Na wyjściu: matryca pikseli określająca prymityw (fragment), dane gotowe do przesłania na bufor ramki Aleksander Dawid rok 112

113 GL Shading Language (GLSL) Teksturowanie i kolorowanie fragmentów Na wejściu: fragment prymitywu Ustalona funkcjonalność Interpolowany kolor mieszany jest z wartością teksela (elementu tekstury) Efekt mgły Rasteryzacja Na wejściu: pokolorowany prymityw i położenie piksela Ustalona funkcjonalność Test przycinania Test alfa Test bufora szablonu Test bufora głębokości Na wyjściu: rysowanie w buforze ramki Aleksander Dawid rok 113

114 GL Shading Language (GLSL) W nowoczesnych układach graficznych dano możliwość programowania funkcjonalności w dwóch poniższych etapach przetwarzania grafiki Transforamcja wierzchołków programowalna jednostka Vertex Shaders Teksturowanie i kolorowanie fragmentów programowalna jednostka Fragment Shaders (pixel shaders) Vertex Shaders Pozwala pisać własny program na transformacje wierzchołków, transformacje normalnych, transformacje współrzędnych tekstur, obliczanie świateł dla pojedynczych wierzchołków, obliczenia kolorów. W momencie użycia jednostki vertex shaders cała ustalona funkcjonalność musi być obsługiwana przez nasz program Odpowiedzialny za zapis wartości gl_position Program ma dostęp do stanu maszyny OpenGL Aleksander Dawid rok 114

115 GL Shading Language (GLSL) Fragment Shaders Zmiana funkcjonalności w zakresie operacji Obliczenia kolorów i współrzędnych tekstur na każdy piksel Nakładanie tekstur Obliczanie mgły Obliczanie normalnych w przypadku oświetlenia na każdy piksel Fragment shaders ma dostęp do położeń poszczególnych pikseli, ale nie może ich zmieniać Na wyjściu: Nie przekazywać nic gl_fragcolor ostateczny kolor dla fragmentu gl_fragdata gdy renderowanie jest dla różnych urządzeń wyświetlających Aleksander Dawid rok 115

116 GLSL - programowanie Inicjalizacja Każdy shader jest jak osobny program napisany w języku C i musi być skompilowany. Aplikacja w OpenGL musi mieć minimum dwa shadery (Vertex shader i Fragment Shader) Do programowania shaderów potrzebna jest obsługa OpenGL2.0 lub rozszerzenia ARB (Archtecture Review Board). Dobrym rozwiązaniem zarówno dla jednego i drugiego przypadku jest biblioteka GLEW Aleksander Dawid rok 116

117 GLSL - programowanie Test rozszerzenia ARB Sprawdzamy czy nasza karta graficzna/system obsługują rozszerzenia GL_ARB_fragment_shader i GL_ARB_vertex_shader //Incjalizacja OpenGL (glut,wingl,glaux) glewinit(); if (GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader) printf("glsl OK\n"); else { printf("brak obsługi GLSL\n"); exit(1); } Aleksander Dawid rok 117

118 GLSL - programowanie Test OpenGL2.0 Sprawdzamy czy nasza karta graficzna/system obsługują rozszerzenia GL_ARB_fragment_shader i GL_ARB_vertex_shader //Incjalizacja OpenGL (glut,wingl,glaux) glewinit(); if (glewissupported("gl_version_2_0")) printf( Gotowy na OpenGL 2.0\n"); else { printf("opengl 2.0 nie wspierane\n"); exit(1); } Aleksander Dawid rok 118

119 GLSL - programowanie Konstrukcja programu Vertex shader glcreateshader glcreateprogram glshadersource glattacheshader glcompileshader glattacheshader FRAGMENT shader glcreateshader gllinkprogram glshadersource gluseprogram glcompileshader Aleksander Dawid rok 119

120 GLSL - programowanie Vertex shader GLuint glcreateshader(glenum shadertype); glcreateshader glshadersource glcompileshader FRAGMENT shader glcreateshader glshadersource glcompileshader shadertype GL_VERTEX_SHADER, GL_FRAGMENT_SHADER Gluint shader; shader = glcreateshader(gl_vertex_shader); shader identyfikator shadera void glshadersource(gluint shader, int numofstrings, const char **strings, int *lenofstrings); numofstrings ilość ciągów w tablicy. strings tablica ciągów. lenofstrings tablica rozmiarów ciągów, albo NULL, oznacza ciągi zakończone znakiem zero NULL void glcompileshader(gluint shader); Aleksander Dawid rok 120

121 GLSL - programowanie Program glcreateprogram GLuint glcreateprogram(void); Funkcja zwraca identyfikator pojemnika. Programów możemy tworzyć ile chcemy. Możemy przełączać się między tymi programami. glattacheshader void glattachshader(gluint program, GLuint shader); glattacheshader gllinkprogram void gllinkprogram(gluint program); void gluseprogram(gluint prog); prog uchwyt do programu który chcemy użyć, lub zero jako powrót do ustalonej funkcjonalności. gluseprogram Aleksander Dawid rok 121

122 GLSL - programowanie Shader program W kodzie GLbyte vshaderstr[] = "attribute vec4 vposition; \n" "void main() \n" "{ \n" " gl_position = vposition; \n" "} \n"; W pliku zewnętrznym char *vs = NULL; vs = File2Text("test.vert"); Aleksander Dawid rok 122

123 GLSL - programowanie char *File2Text(char *filename) { FILE *fp; char *content = NULL; int count=0; if (fn!= NULL) { fp = fopen(filename,"rt"); if (fp!= NULL) { fseek(fp, 0, SEEK_END); count = ftell(fp); rewind(fp); } } } if (count > 0) { content = (char *)malloc(sizeof(char) * (count+1)); count = fread(content,sizeof(char),count,fp); content[count] = '\0'; } fclose(fp); return content; Aleksander Dawid rok 123

124 void UstawShadery() { char *vs,*fs; Ustawienie shadera- przykład v = glcreateshader(gl_vertex_shader); f = glcreateshader(gl_fragment_shader); vs = File2Text("toon.vert"); //vertex shader fs = File2Text("toon.frag"); //fragment shader const char * vv = vs; const char * ff = fs; glshadersource(v, 1, &vv,null); glshadersource(f, 1, &ff,null); free(vs);free(fs); glcompileshader(v); glcompileshader(f); p = glcreateprogram(); glattachshader(p,v); glattachshader(p,f); } gllinkprogram(p); gluseprogram(p); Aleksander Dawid rok 124

125 Sprawdzanie poprawności kodu Dla shaderów nie ma możliwości sprawdzenia poprawności kodu. Narzędzia dostępne w OpenGL 2.0 void glgetshaderiv(gluint object, GLenum type, int *param); object uchwyt do shadera lub programu type GL_COMPILE_STATUS. param zwracana wartość, GL_TRUE kompilacja prawidłowa, GL_FALSE błędy przy kompilacji. void glgetprogramiv(gluint object, GLenum type, int *param); object uchwyt do shadera lub programu type GL_LINK_STATUS. param zwracana wartość, GL_TRUE kompilacja prawidłowa, GL_FALSE błędy przy kompilacji. Aleksander Dawid rok 125

126 Poprawności kodu InfoLog W przypadku błędów podczas przetwarzania programu przez kartę graficzną, sterownik generuje dziennik (InfoLog). Format tego dziennika zależny jest od sterownika urządzenia. void glgetshaderinfolog(gluint object, int maxlen, int *len, char *log); void glgetprograminfolog(gluint object, int maxlen, int *len, char *log); object uchwyt do shadera lub programu maxlen maksymalna liczba znaków do pobrania z pliku InfoLog. len zwraca aktualny rozmiar pliku InfoLog. log Nazwa pliku InfoLog. Pobranie rozmiaru pliku InfoLog void glgetshaderiv(gluint object, GLenum type, int *param); void glgetprogramiv(gluint object, GLenum type, int *param); object uchwyt do shadera lub programu type GL_INFO_LOG_LENGTH. param rozmiar pliku InfoLog. Aleksander Dawid rok 126

127 Odczyt InfoLog przykład void printshaderinfolog(gluint obj) { int infologlength = 0; int charswritten = 0; char *infolog; //glgetprogramiv(obj, GL_INFO_LOG_LENGTH,&infologLength); glgetshaderiv(obj, GL_INFO_LOG_LENGTH,&infologLength); } if (infologlength > 0) { infolog = (char *)malloc(infologlength); glgetshaderinfolog(obj, infologlength, &charswritten, infolog); printf("%s\n",infolog); free(infolog); } Aleksander Dawid rok 127

128 Kasowanie shaderów Przed skasowaniem shadery muszą być odłączone od programu void gldetachshader(gluint program, GLuint shader); program identyfikator programu. shader identyfikator shadera do odłączenia. Kasowanie void gldeleteshader(gluint id); void gldeleteprogram(gluint id); id identyfikator programu lub shadera, który ma zostać skasowany. Aleksander Dawid rok 128

129 Komunikacja OpenGL Shader Wynik działania programu shadera przekazywany jest tylko w postaci graficznej do bufora koloru lub głębokości, więc komunikacja jest tylko jednokierunkowa. GLSL pozwala na definiowanie zmiennych do komunikacji z shaderami GLSL obsługuje dwa modyfikatory zmiennych Attribute Uniform Zmienne używające tych modyfikatorów są tylko do odczytu przez shader. Inną metodą przesyłania danych do shaderów są tekstury, które mogą reprezentować tablicę liczb. Aleksander Dawid rok 129

130 UNIFORM Zmienne Wartości mogą być zmieniane tylko przez prymitywy. Aby ustawić zmienną UNIFORM trzeba najpierw pobrać jej adres z programu shadera w postaci nazwy. Program shadera musi być zlinkowany i użyty. GLint glgetuniformlocation(gluint program, const char *name); program identyfikator programu. name nazwa zmiennej. Zwracana wartość z tej funkcji to identyfikator położenia, na podstawie którego możemy przypisać wartość do zmiennej. void gluniform1f(glint location, GLfloat v0); void gluniform2f(glint location, GLfloat v0, GLfloat v1); void gluniform3f(glint location, GLfloat v0, GLfloat v1, GLfloat v2); void gluniform4f(glint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); GLint gluniform{1,2,3,4}fv(glint location, GLsizei count, GLfloat *v); Aleksander Dawid rok 130

131 Zmienne GLint gluniformmatrix{2,3,4}fv(glint location, GLsizei count, GLboolean transpose, GLfloat *v); location położenie zmiennej. count liczba macierzy. transpose macierz transponowana Anm=Bmn v tablica liczb zmiennoprzecinkowych. Ustawione wartości istnieją tak długo w pamięci dopóki program nie zostanie ponownie zlinkowany. PRZYKŁAD Aleksander Dawid rok 131

132 ATTRIBUTE Zmienne Wartości mogą być ustawiane na wierzchołek pomiędzy glbegin glend. Aby ustawić zmienną ATTRIBUTE trzeba najpierw pobrać jej adres z programu shadera w postaci nazwy. Program shadera musi być zlinkowany i użyty. GLint glgetattriblocation(gluint program,char *name); program identyfikator programu. name nazwa zmiennej. Zwracana wartość z tej funkcji to identyfikator położenia, na podstawie którego możemy przypisać wartość do zmiennej. void glvertexattrib1f(glint location, GLfloat v0); void glvertexattrib2f(glint location, GLfloat v0, GLfloat v1); void glvertexattrib3f(glint location, GLfloat v0, GLfloat v1,glfloat v2); void glvertexattrib4f(glint location, GLfloat v0, GLfloat v1,,glfloat v2, GLfloat v3); GLint glvertexattrib{1,2,3,4}fv(glint location, GLfloat *v); Aleksander Dawid rok 132

133 ATTRIBUTE przykład Zmienne glbegin(gl_triangle_strip); glvertexattrib1f(loc,5.0); glvertex2f(-1,1); glvertexattrib1f(loc,2.0); glvertex2f(1,1); glvertexattrib1f(loc,-2.0); glvertex2f(-1,-1); Zwracana wartość glvertexattrib1f(loc,-2.0); z tej funkcji to identyfikator położenia, na podstawie którego możemy przypisać glvertex2f(1,-1); wartość do zmiennej. glend(); Aleksander Dawid rok 133

134 Typy zmiennych shader program Typy proste int bool float Typy wektorowe vec{2,3,4} (float) bvec{2,3,4} (bool) ivec{2,3,4} (int) Typy macierzowe mat2 macierz 2x2 mat3 - macierz 3x3 mat4 - macierz 4x4 Aleksander Dawid rok 134

135 Typy zmiennych shader program Typy teksturowe, dotyczą tekseli sampler1d dla tekstur 1D sampler2d dla tekstur 2D sampler3d dla tekstur 3D Tablice tych zmiennych deklarujemy tak samo jak w języku C vect3 A[10]; mat4 Tab[2]; Struktury struct spotlight { vec3 kierunek; vec3 kolor; }; spotlight A; A.kierunek=vec3(1.0,1.0,1.0); Aleksander Dawid rok 135

136 Instrukcje sterujące IF-ELSE if (bool warunek)... else... FOR for (inicjalizacja; warunek; zmiana wartości)... WHILE while (warunek)... DO-WHILE do... while (warunek) Aleksander Dawid rok 136

137 Funkcje Funkcje deklaruje się podobnie jak w języku C void main() vec4 ChangeColor(in float intensity){ vec4 color; color = vec4(intensity, intensity, intensity,1.0); return(color); } Modyfikatory: in,out,inout Domyślny in Aleksander Dawid rok 137

138 Zmienna varying Zmienna przenoszona pomiędzy programem Vertex Shader a Fragment Shader varying float intensity; Aleksander Dawid rok 138

139 Przykład Vertex Shader void main(){ gl_position = gl_modelviewprojectionmatrix * gl_vertex; } Fragment Shader void main(){ gl_fragcolor = gl_color; } Aleksander Dawid rok 139

140 Przykład Windows API GLSL Omówienie interfejsu OpenGL dla Windows Aleksander Dawid rok 140

141 Powiązanie technologii GLSL z WinApi Czynności wstępne case WM_CREATE: /* Tworzenie kontekstu renderowania OpenGL */ ghdc = GetDC(hWnd); setuppixelformat(ghdc); ghrc = wglcreatecontext(ghdc); wglmakecurrent(ghdc, ghrc); GetClientRect(hWnd, &rect); initializegl(rect.right, rect.bottom); SetTimer(hWnd, 101, 5, NULL); break; Aleksander Dawid rok 141

142 Powiązanie technologii GLSL z WinApi Pobranie kontekstu urządzenia wyświetlającego ghdc = GetDC(hWnd); Ustalenie formatu Pikseli setuppixelformat(ghdc); Utworzenie kontekstu OpenGL ghrc = wglcreatecontext(ghdc); Ustawienie kontekstu OpenGL jako bierzącego wglmakecurrent(ghdc, ghrc); Aleksander Dawid rok 142

143 Powiązanie technologii GLSL z WinApi Pobranie rozmiaru okna roboczego GetClientRect(hWnd, &rect); Inicjalizacja parametrów OpenGL i GLSL initializegl(rect.right, rect.bottom); Ustawienie timera jako dodatkowego wątku kontrolującego animację SetTimer(hWnd, 101, 5, NULL); Aleksander Dawid rok 143

144 Inicjalizacja grafiki OpenGL GLvoid initializegl(glsizei width, GLsizei height) { glclearcolor( 0.0f, 0.0f, 0.0f, 0.0f); glcleardepth( 1.0 ); glshademodel(gl_smooth); glenable(gl_depth_test); InitGLSL(); InitShaders(); } GLSL InitGLSL(); InitShaders(); Aleksander Dawid rok 144

145 Inicjalizacja biblioteki Shaderów Do inicjalizacji shaderów służy biblioteka GLEW: The OpenGL Extension Wrangler Library #include <GL/glew.h> W celu wykorzystania tej biblioteki w systemie Windows trzeba wykonać kompilację jej kodu źródłowego glew32d.dll biblioteka dynamiczna glew32d.lib biblioteka statyczna Biblioteka wykorzystuje zarówno kartę graficzną jak i emuluje bibliotekę shaderów w przypadku ich braku. Aleksander Dawid rok 145

146 Inicjalizacja biblioteki Shaderów Instrukcja glewinit(); inicjalizuje bibliotekę GLEW GLvoid InitGLSL(){ glewinit(); if (GLEW_VERSION_2_0){ MessageBox(ghWnd, "INFO: OpenGL 2.0 wspierany", Informacja",MB_OK); }else{ MessageBox(ghWnd, "INFO: OpenGL 2.0 nie wspierany", " Informacja",MB_OK); } } glewinit(); musi być wywołane po inicjalizacji biblioteki OpenGL Jeżeli zmienna boolowska GLEW_VERSION_2_0=prawda to możemy skorzystać z funkcjonalności jaką oferuje standard OpenGL2.0 Aleksander Dawid rok 146

147 GLvoid InitShaders(){ char shaderfn[]="wave.vert"; char fragmentfn[]="wave.frag"; char Info[64]; Program Shaderów char *vssource = textfileread(shaderfn); if(vssource==null){ sprintf(info,"plik: %s nie znaleziony",shaderfn); MessageBox(ghWnd, Info, "Informacja",MB_OK); exit(0); } char *fssource = textfileread(fragmentfn); if(fssource==null){ sprintf(info,"plik: %s nie znaleziony",fragmentfn); MessageBox(ghWnd, Info, "Informacja",MB_OK); exit(0); } Aleksander Dawid rok 147

148 Program Shaderów const char * vv = vssource; const char * ff = fssource; vs = glcreateshader(gl_vertex_shader); fs = glcreateshader(gl_fragment_shader); glshadersource(vs, 1, &vv, NULL); glshadersource(fs, 1, &ff, NULL); free(vssource); free(fssource); glcompileshader(vs); glcompileshader(fs); printlog(vs); printlog(fs); Aleksander Dawid rok 148

149 Program Shaderów sp = glcreateprogram(); glattachshader(sp, vs); glattachshader(sp, fs); gllinkprogram(sp); printlog(sp); gluseprogram(sp); } Aleksander Dawid rok 149

150 Falująca powierzchnia Efekt falującej powierzchni jest często stosowany w grafice komputerowej; woda, flaga, trawa itd. Do czasu zanim zostały wprowadzone shadery wykonywany był przez procesor główny komputera. Dla wielkie ilości wierzchołków był praktycznie niemożliwy do wykonania w grach komputerowych. Aleksander Dawid rok 150

151 Falująca powierzchnia Algorytm Start Inicjalizacja OpenGL Wierzchołki Vertex Shader Pixel Shader i<n i=i+1 Aleksander Dawid rok 151

152 Vertex shader Fala uniform float wavetime; uniform float wavewidth; uniform float waveheight; void main(void) { vec4 gv = vec4(gl_vertex); gv.z = sin(wavewidth * gv.x + wavetime) * cos(wavewidth * gv.y + wavetime) * waveheight; } gl_position = gl_modelviewprojectionmatrix * gv; Aleksander Dawid rok 152

153 Vertex shader Fala uniform float wavetime; uniform float wavewidth; uniform float waveheight; Zmienne uniform to zmienne dostępne dla naszego programu. Przy ich pomocy możemy w czasie rzeczywistym modyfikować zachowanie fali. Aby zmodyfikować te zmienne musi nasz program shadera być już uruchomiony. GLvoid InitWave(){ wavetimeloc = glgetuniformlocation(sp, "wavetime"); wavewidthloc = glgetuniformlocation(sp, "wavewidth"); waveheightloc = glgetuniformlocation(sp, "waveheight"); printlog(sp); } Aleksander Dawid rok 153

154 Vertex shader Fala GLvoid initializegl(glsizei width, GLsizei height) {... InitShaders(); InitWave(); } Adresy w pamięci karty graficznej GLint wavetimeloc; GLint wavewidthloc; GLint waveheightloc; Inicjalizacja zmiennych w CPU GLfloat wavetime = 0.0; Glfloat wavewidth = 0.2; Glfloat waveheight = 5.0; Glfloat wavefreq = 0.1; Aleksander Dawid rok 154

155 Vertex shader Fala gl_vertex - wierzchołki, które będą poddane obróbce przez nasz program Równanie fali płaskiej. z f ( x, y) Asin( Wx t)cos( Wy t) Modyfikacji podlega tylko składowa z gv.z = sin(wavewidth * gv.x + wavetime) * cos(wavewidth * gv.y + wavetime) * waveheight; Zmodyfikowane pozycje wierzchołków gl_position = gl_modelviewprojectionmatrix * gv; Aleksander Dawid rok 155

156 Fragment shader Fala gl_fragcolor - Ostateczny kolor fragmentów void main() { gl_fragcolor[0] = gl_fragcoord[0] / 400.0; gl_fragcolor[1] = gl_fragcoord[1] / 400.0; gl_fragcolor[2] = 1.0; } gl_fragcoord - Współrzędne fragmentów Aleksander Dawid rok 156

157 Płaszczyzna wielokatów Fala GLvoid PlainSurface() { int i,j; glbegin(gl_quads); for (i = -50; i < 50; i++) for (j = -50; j < 50; j++) { glvertex2f(i, j); glvertex2f(i + 1, j); glvertex2f(i + 1, j + 1); glvertex2f(i, j + 1); } glend(); } Aleksander Dawid rok 157

158 Pętla animacji Fala GLvoid drawscene(glvoid) { glclearcolor( 0.0f, 0.0f, 0.4f, 0.0f); glclear(gl_color_buffer_bit GL_DEPTH_BUFFER_BIT); gluniform1f(wavetimeloc, wavetime); gluniform1f(wavewidthloc, wavewidth); gluniform1f(waveheightloc, waveheight); } PlainSurface(); wavetime += wavefreq; SWAPBUFFERS; Animacja wykonywana jest w osobnym wątku ustawionym przez timer wavewidth, waveheight - Można modyfikować w głównym wątku Aleksander Dawid rok 158

159 Cieniowanie Phonga Stosowane bardzo często w grafice wektorowej w celu reprezentacji rozbłysków Vertex Shader varying vec3 N; varying vec3 v; void main(void) { v = vec3(gl_modelviewmatrix * gl_vertex); N = normalize(gl_normalmatrix * gl_normal); gl_position = gl_modelviewprojectionmatrix * gl_vertex; } Aleksander Dawid rok 159

160 Fragment Shader varying vec3 N; varying vec3 v; Cieniowanie Phonga void main (void) { vec3 L = normalize(gl_lightsource[0].position.xyz - v); vec3 E = normalize(-v); vec3 R = normalize(-reflect(l,n)); L wektor światła E odwrotny wektor modelu R wektor odbicia Aleksander Dawid rok 160

161 Fragment Shader Cieniowanie Phonga //Kolor otoczenia (Ambient): vec4 Iamb = gl_frontlightproduct[0].ambient; //Kolor rozpraszania (Diffuse): vec4 Idiff = gl_frontlightproduct[0].diffuse * max(dot(n,l), 0.0); Idiff = clamp(idiff, 0.0, 1.0); // Kolor rozbłysków (Specular): vec4 Ispec = gl_frontlightproduct[0].specular *pow(max(dot(r,e),0.0),0.3*gl_frontmaterial.shininess); Ispec = clamp(ispec, 0.0, 1.0); // Całkowity Kolor: gl_fragcolor = gl_frontlightmodelproduct.scenecolor + Iamb + Idiff + Ispec; } Aleksander Dawid rok 161

162 Cieniowanie Phonga Przekazywanie zmiennych Zmienne typu varying mogą być przekazywane między vertex shader a fragment shader Cały algorytm bazuje na wektorach normalnych, które liczone są w jednostce vertex shader. Aleksander Dawid rok 162

163 Cieniowanie Phonga Porównanie standardowego cieniowania wielokątów z cieniowaniem Phonga przy użyciu shaderów. Aleksander Dawid rok 163

164 WebGL Standard OpenGL ES Aleksander Dawid rok 164

165 WebGL Standard stworzony do obróbki grafiki 3D w przeglądarce internetowej. WebGL bazuje na bibliotekach OpenGL for Embeded Systems. Grafika tworzona jest w całości przez kartę graficzną, która obsługuje minimalnie OpenGL 2.0 lub OpenGL ES 2.0. Główni dostawcy przeglądarek Apple (Safari), Google (Chrome), Mozilla (Firefox), i Opera (Opera) są członkami WebGL Working Group. Aleksander Dawid rok 165

166 WebGL WebGL korzysta z osadzenia w znaczniku canvas z HTML5. Programowanie API WebGL odbywa się przy pomocy języka JavaScript. WebGL jest w 100% kompatybilny z OpenGL ES. Do transformacji wierzchołków i renderowania fragmentów wykorzystuje programy shaderów. WebGL nie wymaga instalowania dodatkowych bibliotek. Aleksander Dawid rok 166

167 WebGL Inicjalizacja okna WebGL Kod HTML5 <HTML> <HEAD> <SCRIPT type="text/javascript"> // Kod JavaScript </SCRIPT> </HEAD> <BODY onload="startgl()" bgcolor="white"> <canvas id="glid" width="640" height="480"> Brak wsparcia dla technologii HTML5 </canvas> </BODY> </HTML> Aleksander Dawid rok 167

168 Inicjalizacja okna WebGL Kod JavaScript WebGL var gl; function startgl(){ var canvas=document.getelementbyid("glid"); gl = null; try{gl=canvas.getcontext("experimental-webgl");} catch(e){} } if(!gl){ alert("brak wsparcia sprzętowego dla OpenGL (WebGL)"); return; }else{ gl.clearcolor(0.2,0.2,0.6,1.0); gl.clear(gl.color_buffer_bit gl.depth_buffer_bit); } Aleksander Dawid rok 168

169 Rysowanie WebGL W celu wyświetlenia wierzchołka w oknie WebGL potrzeba wykonać następujące czynności. 1. Utworzyć Vertex Shader 2. Utworzyć FragmentShader 3. Skompilować i zlinkować program shaderów 4. Wpisać wierzchołki do tablicy 5. Uruchomić program shaderów 6. Pobrać atrybut położenia z vertex shadera 7. Przekazać położenia z tablicy do vertex shadera 8. Wydać komendą wyświetlania tablicy Dla wielu różnych obiektów czynności te trzeba powtórzyć. Aleksander Dawid rok 169

170 Deklaracja tablicy wierzchołków A. Przypisanie w trakcie deklaracji tablicy Punkty3D = [ 0.0, 0.5, 0.0, 0.5, -0.5, 0.0, -0.5, -0.5, 0.0]; B. Wypełnianie tablicy algorytmicznie WebGL Punkty3D = []; skok=0.5; iter=-0.5; for(i=0;i<9;i++){ if(i%3==0){ Punkty3D.push(iter); iter=iter+skok; }else{ Punkty3D.push(0.0); } } Aleksander Dawid rok 170

171 Deklaracja Vertex Shadera WebGL A. Wewnątrz ciągu znaków var VShader="attribute vec4 pozycja; "+ " void main() " + "{" + "gl_position = pozycja;"+ "gl_pointsize = 30.0;"+ "}"; B. Wewnątrz dodatkowego znacznika <SCRIPT> <script id="vertex-shader" type="x-shader/x-vertex"> attribute vec4 pozycja; void main() { gl_position = pozycja; gl_pointsize = 30.0; } </script> Aleksander Dawid rok 171

172 Przekazywanie wierzchołków A. Przez zmienne attribute Zmienna gl_position przekazuje wierzchołki do dalszego renderowania. attribute vec4 pozycja; void main() { gl_position = pozycja; gl_pointsize = 30.0; } WebGL var coor = gl.getattriblocation(shaderprogram, "pozycja"); gl.vertexattrib4f(coor, g_points[0], g_points[1], g_points[2], 1.0); gl.drawarrays(gl.points, 0, 1); //Przekazanie 1 wierzchołka Wada: transfer z CPU do GPU każdego wierzchołka. Aleksander Dawid rok 172

173 Przekazywanie wierzchołków B. Przez bufor GPU WebGL Punkty3D = [ 0.0, 0.5, 0.0, 0.5, -0.5, 0.0, -0.5, -0.5, 0.0]; var vertex_buffer = gl.createbuffer(); gl.bindbuffer(gl.array_buffer, vertex_buffer); gl.bufferdata(gl.array_buffer, new Float32Array(Punkty3D), gl.static_draw); // kopiowanie danych wierzchołków //Połaczenie bufora z Vertex Shaderem var coord = gl.getattriblocation(shaderprogram, "pozycja"); gl.vertexattribpointer(coord, 3, gl.float, false, 0, 0); gl.enablevertexattribarray(coord); //Przekazanie 3 wierzchołków z bufora GPU gl.drawarrays(gl.points, 0, Punkty3D.length/3); Aleksander Dawid rok 173

174 Fragment Shader WebGL <script id="fragment-shader" type="x-shader/x-fragment"> precision mediump float; uniform vec4 kolor; void main() { gl_fragcolor = kolor; } </script> highp, mediump, lowp precyzja obliczeń Do fragment shadera parametry można przesyłać tylko w zmiennych uniform. Aleksander Dawid rok 174

175 Fragment Shader Zmiana koloru przez zmienną var nk = gl.getuniformlocation(shaderprogram, "kolor"); gl.uniform4f( nk, 1.0, 0.0, 0.0, 1.0 ); gl.drawarrays(gl.points, 0, 1); gl.uniform4f( nk, 0.0, 1.0, 0.0, 1.0 ); gl.drawarrays(gl.points, 1, 1); gl.uniform4f( nk, 0.0, 0.0, 1.0, 1.0 ); gl.drawarrays(gl.points, 2, 1); WebGL gl.drawarrays(gl.points, start, length); start offset w buforze GPU lenght rozmiar liczony w rozmiarze wektor 3-elementowego. Aleksander Dawid rok 175

176 Fragment Shader WebGL Zmiana koloru ze względu na dane w Vertex Shader attribute vec4 pozycja; varying vec4 N; //zmienna dostępna we Fragment Shader void main() { N = pozycja; gl_position = pozycja; gl_pointsize = 30.0; } Przekazujemy w zmiennej N pozycje każdego z wierzchołków Aleksander Dawid rok 176

177 Fragment Shader Zmiana koloru ze względu na dane w Vertex Shader precision mediump float; varying vec4 N; WebGL void main() { vec4 kolor; if(n.x<0.0) kolor=vec4(1.0,0.0,0.0,1.0); if(n.x==0.0) kolor=vec4(0.0,1.0,0.0,1.0); if(n.x>0.0) kolor=vec4(0.0,0.0,1.0,1.0); } gl_fragcolor = kolor; gl.drawarrays(gl.points, 0, Punkt3D.length/3); Aleksander Dawid rok 177

178 Kompilacja Shaderów WebGL var vertelem = document.getelementbyid(vertexshaderid); //Pobranie lokalizacji znacznika <SCRIPT id=vertexshaderid> vertshdr = gl.createshader(gl.vertex_shader); gl.shadersource(vertshdr, vertelem.text); // vertelem.text tekst wewnątrz znacznika gl.compileshader(vertshdr); if (!gl.getshaderparameter(vertshdr, gl.compile_status)) { var msg = "Vertex shader nie można skompilowć:" + "<pre>" + gl.getshaderinfolog(vertshdr) + "</pre>"; alert(msg); console.log(msg); return -1; } Aleksander Dawid rok 178

179 Kompilacja Shaderów WebGL if(n.x<0) kolor=vec4(1.0,0.0,0.0,1.0); Aleksander Dawid rok 179

180 Kompilacja Shaderów WebGL fragshdr = gl.createshader(gl.fragment_shader); gl.shadersource(fragshdr, fragelem.text); gl.compileshader(fragshdr); var program = gl.createprogram(); gl.attachshader(program, vertshdr); gl.attachshader(program, fragshdr); gl.linkprogram(program); if (!gl.getprogramparameter(program, gl.link_status)) { var msg = "Shader program nie można zlinkować:" + "<pre>" + gl.getprograminfolog(program) + "</pre>"; alert(msg); console.log(msg); return -1; } Aleksander Dawid rok 180

181 Użycie Shaderów WebGL var vertex_buffer = gl.createbuffer(); gl.bindbuffer(gl.array_buffer, vertex_buffer); gl.bufferdata(gl.array_buffer, new Float32Array(g_points), gl.static_draw); var shaderprogram = initshaders( gl, "vertex-shader", "fragment-shader" ); //Program shaderów musi być uruchomiony gl.useprogram(shaderprogram); var coord = gl.getattriblocation(shaderprogram, "pozycja"); gl.vertexattribpointer(coord, 3, gl.float, false, 0, 0); gl.enablevertexattribarray(coord); gl.clearcolor(0.6,0.6,1.0,1.0); //Ustawienie koloru tła gl.clear(gl.color_buffer_bit gl.depth_buffer_bit); gl.drawarrays(gl.points, 0, g_points.length/3); Aleksander Dawid rok 181

182 Rysowanie trójkątów Położenia wierzchołków g_points = [ 0.0, 0.5, 0.0, 0.5, -0.5, 0.0, -0.5, -0.5, 0.0]; Kolory wierzchołków color_points = [ 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0,]; Vertex shader attribute vec4 pozycja; attribute vec4 pozycjacolor; varying vec4 N; WebGL Wypełnianie gradientowe void main() { gl_position = pozycja; N = pozycjacolor; } Aleksander Dawid rok 182

183 Rysowanie trójkątów Fragment shader precision mediump float; varying mediump vec4 N; void main() { gl_fragcolor = N; } WebGL Wypełnianie gradientowe Inicjalizacja buforów var vertex_buffer = gl.createbuffer(); gl.bindbuffer(gl.array_buffer, vertex_buffer); gl.bufferdata(gl.array_buffer, new Float32Array(g_points), gl.static_draw); var VerticesColorBuffer = gl.createbuffer(); gl.bindbuffer(gl.array_buffer, VerticesColorBuffer); gl.bufferdata(gl.array_buffer, new Float32Array(color_points), gl.static_draw); Aleksander Dawid rok 183

184 Rysowanie trójkątów WebGL Przed samym wyświetleniem gl.bindbuffer(gl.array_buffer, vertex_buffer); gl.vertexattribpointer(coord, 3, gl.float, false, 0, 0); gl.bindbuffer(gl.array_buffer, VerticesColorBuffer); gl.vertexattribpointer(coordcolor, 4, gl.float, false, 0, 0); gl.drawarrays(gl.triangles, 0, 3); Aleksander Dawid rok 184

185 Oświetlenie WebGL Wektory normalne normal_points = [ 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0]; Aleksander Dawid rok 185

186 Oświetlenie Vertex Shader attribute vec3 pozycja; attribute vec3 pozycjanorm; varying vec3 N; varying vec3 Pos; WebGL void main() { gl_position = vec4(pozycja,1.0); N = pozycjanorm; //Przekazanie normalnych do Fragment shadera Pos = pozycja; //Przekazanie położenia do Fragment shadera } Aleksander Dawid rok 186

187 Oświetlenie Fragment Shader precision mediump float; varying vec3 N; varying vec3 Pos; WebGL void main() { vec4 Ambient = vec4(0.6,0.0,0.0,1.0); // Ambient Color vec4 Diffuse = vec4(1.0,1.0,0.0,1.0); // Diffuse Color vec3 Light_pos = vec3(0.0,-0.2,0.3); // Wektor Promienia od źródła światła do wierzchołka vec3 Ray = normalize(light_pos - Pos); // Iloczyn skalarny wektora Normalnego i wektora promienia float DiffAmp = max(dot(n,ray), 0.0); vec4 DiffV = Diffuse*DiffAmp; DiffV = clamp(diffv, 0.0, 1.0); // Normalizacja do [0.0,1.0] vec4 Suma = Ambient + DiffV; gl_fragcolor = Suma; } Aleksander Dawid rok 187

188 Teksturowanie attribute vec3 pozycja; attribute vec2 atexturecoord; varying mediump vec2 vtexturecoord; void main() { gl_position = vec4(pozycja,1.0); vtexturecoord = atexturecoord; } WebGL W procesie nakładania tekstur na trójkąty bardzo ważne są współrzędne tekstury. Przesyłana one są z Vertex Shadera do Fragment Shadera Vertex Shader Fragment Shader varying mediump vec2 vtexturecoord; uniform sampler2d usampler; } void main() { gl_fragcolor = texture2d(usampler, vtexturecoord); Aleksander Dawid rok 188

189 Teksturowanie WebGL Ustalenie współrzędnych tekstury dla kwadratu=2 trójkąty Wierzchołki var si=0.5; wall_points = [ -si, -si, 0.0, si, -si, 0.0, -si, si, 0.0, -si, si, 0.0, si, -si, 0.0, si, si, 0.0 ]; 0.0, 1.0 Współrzędne tekstury wall_texcoor = [ 1.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0 ]; 1.0, , , 0.0 Aleksander Dawid rok 189

190 Teksturowanie WebGL Ładowanie Obrazka InitTextures=function() { walltexture = gl.createtexture(); wallimage = new Image(); wallimage.src = "jatex.jpg"; } Sprawdzenie czy rozmiary obrazka są potęgą liczby 2 function ispowerof2(value) { return (value & (value - 1)) == 0; }; Aleksander Dawid rok 190

191 Teksturowanie WebGL Parametry tekstury TextureParams=function(texture,image) { gl.bindtexture(gl.texture_2d, texture); gl.teximage2d(gl.texture_2d, 0, gl.rgba, gl.rgba, gl.unsigned_byte, image); if (ispowerof2(image.width) && ispowerof2(image.height)) { gl.texparameteri(gl.texture_2d, gl.texture_mag_filter, gl.linear); gl.texparameteri(gl.texture_2d, gl.texture_min_filter, gl.linear_mipmap_linear); gl.generatemipmap(gl.texture_2d); } else { gl.texparameteri(gl.texture_2d, gl.texture_wrap_s, gl.clamp_to_edge); gl.texparameteri(gl.texture_2d, gl.texture_wrap_t, gl.clamp_to_edge); gl.texparameteri(gl.texture_2d, gl.texture_min_filter, gl.linear); } } Aleksander Dawid rok 191

192 Teksturowanie WebGL Problemy przy teksturowaniu WebGL Asynchroniczne wczytywanie plików graficznych. Problem dotyczy JavaScript i polega na wcześniejszym wywołaniu instrukcji renderujących teksturę niż wczytanie samego pliku który ma być teksturą. Zabezpieczenia przeglądarek internetowych. Pliki zewnętrzne (obrazy tekstur) nie mogą być pobierane podczas uruchamiania strony internetowej (plik HTML) z lokalnego folderu. Obraz taki można tylko pobrać z serwera WWW (HTTP). Aleksander Dawid rok 192

193 Teksturowanie WebGL Renderowanie tekstury na trójkątach. wallimage.onload = function() { gl.clearcolor(0.9,0.9,1.0,1.0); //Ustawienie koloru tła gl.clear(gl.color_buffer_bit gl.depth_buffer_bit); gl.bindbuffer(gl.array_buffer, vertex_buffer); gl.vertexattribpointer(coord, 3, gl.float, false, 0, 0); gl.bindbuffer(gl.array_buffer, texcoor_buffer); gl.vertexattribpointer(texturecoordattribute, 2, gl.float, false, 0, 0); var textureunit = 1; TextureParams(wallTexture,wallImage); } gl.activetexture(gl.texture0+textureunit); gl.bindtexture(gl.texture_2d, walltexture); gl.uniform1i(samp, textureunit); gl.drawarrays(gl.triangles, 0, 6); Aleksander Dawid rok 193

194 Teksturowanie WebGL Ustalenie współrzędnych tekstury dla kwadratu=2 trójkąty 0.0, , , , , , , , 0.0 Aleksander Dawid rok 194

195 Rzutowanie perspektywiczne WebGL Aleksander Dawid rok 195

196 WebGL Aleksander Dawid rok 196 Rzutowanie perspektywiczne Macierz perspektywy P v v far near far near far near far near ar P * 0 * 2* tan / 2 tan

197 WebGL Aleksander Dawid rok 197 Rzutowanie perspektywiczne Macierz Widoku M MW P v v MW * * Macierz Translacji x x z y x z y x T x T z y x x T T T z y x z y x T T T MT 1* *0 *0 * ,1,,,1,, Macierz Skalowania z y x S S S MS

198 WebGL Aleksander Dawid rok 198 Rzutowanie perspektywiczne Macierze Obrotu wokół osi x ) cos( ) sin( 0 0 ) sin( ) cos( O x Macierze Obrotu wokół osi y ) cos( 0 ) sin( ) sin( 0 ) cos( O y Macierze Obrotu wokół osi z ) cos( ) sin( 0 0 ) sin( ) cos( O z

199 Rzutowanie perspektywiczne WebGL Macierz perspektywy (JavaScript) makeperspective=function(fieldofviewinradians, aspect, near, far) { var f = Math.tan(Math.PI * * fieldofviewinradians); var rangeinv = 1.0 / (near - far); return [ f / aspect, 0, 0, 0, 0, f, 0, 0, 0, 0, (near + far) * rangeinv, -1, 0, 0, near * far * rangeinv * 2, 0 ]; }; Aleksander Dawid rok 199

200 Rzutowanie perspektywiczne WebGL makeident=function() { return [ 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0 ]; }; perspectivematrix = makeperspective(45.0*math.pi/180.0, 400.0/400.0, 0.1, 100.0); MMatrix = makeident(); Przekazanie macierzy perspektywy i modelu do Vertex Shadera var PM = gl.getuniformlocation(shaderprogram, "ProjMatrix"); gl.uniformmatrix4fv(pm, false, new Float32Array(perspectiveMatrix)); var MM = gl.getuniformlocation(shaderprogram, "ModelMatrix"); gl.uniformmatrix4fv(mm, false, new Float32Array(MMatrix)); Aleksander Dawid rok 200

201 Rzutowanie perspektywiczne WebGL Perspektywa (C, Vertex Shader) attribute vec3 pozycja; attribute vec3 pozycjanorm; uniform mat4 ProjMatrix; uniform mat4 ModelMatrix; varying vec3 N; varying vec3 Pos; void main() { gl_position = ProjMatrix*ModelMatrix*vec4(pozycja,1.0); N = pozycjanorm; Pos = pozycja; } Aleksander Dawid rok 201

202 Translacje WebGL Wektor przesunięcia trans = [1.0, -1.0, -4.0]; Przekazanie do Vertex Shadera var trans = gl.getattriblocation(shaderprogram, "TransW"); gl.vertexattrib4f(trans, trans[0], trans[1], trans[2], 1.0); Translacja Vertex Shadera void main() { mat4 TrMat = mat4( vec4(1.0, 0.0, 0.0, 0.0), vec4(0.0, 1.0, 0.0, 0.0), vec4(0.0, 0.0, 1.0, 0.0), vec4(transw.x, TransW.y, TransW.z, 1.0) ); mat4 ModMat = ModelMatrix*TrMat; gl_position = ProjMatrix*ModMat*vec4(pozycja,1.0); } Aleksander Dawid rok 202

203 Translacje WebGL Przykład. Przesuwanie trójkąta w kierunku Z Aleksander Dawid rok 203

204 Animacja WebGL Animacja wywoływana jest z poziomu JavaScript window.requestanimationframe(render); Metoda z klasy Window wywołuje funkcję Render render=function() { gl.clear(gl.color_buffer_bit); if(xcor>0.8) step=-step; if(xcor<-0.8) step=-step; Xcor+=step; } gl.uniform1f( Xpos, Xcor ); gl.uniform1f( Scale, 8.0 ); gl.drawarrays(gl.triangle_fan, 0, vertices.length/3); window.requestanimationframe(render); Aleksander Dawid rok 204

205 Najważniejsze funkcje języka Shaderów Konwersja radianów do stopni float radians(float degrees) vec2 radians(vec2 degrees) vec3 radians(vec3 degrees) vec4 radians(vec4 degrees) Konwersja stopni do radianów float degrees(float radians) vec2 degrees(vec2 radians) vec3 degrees(vec3 radians) vec4 degrees(vec4 radians) Aleksander Dawid rok 205

206 Najważniejsze funkcje języka Shaderów Funkcje trygonometryczne Funkcja sinus float sin(float angle) vec2 sin(vec2 angle) vec3 sin(vec3 angle) vec4 sin(vec4 angle) Funkcja cosinus float cos(float angle) vec2 cos(vec2 angle) vec3 cos(vec3 angle) vec4 cos(vec4 angle) Aleksander Dawid rok 206

207 Najważniejsze funkcje języka Shaderów Funkcje trygonometryczne Funkcja tangens float tan(float angle) vec2 tan(vec2 angle) vec3 tan(vec3 angle) vec4 tan(vec4 angle) Funkcja arcus sinus float asin(float x) vec2 asin(vec2 x) vec3 asin(vec3 x) vec4 asin(vec4 x) Aleksander Dawid rok 207

208 Najważniejsze funkcje języka Shaderów Funkcje trygonometryczne Funkcja arcus cosinus float acos(float x) vec2 acos(vec2 x) vec3 acos(vec3 x) vec4 acos(vec4 x) Funkcja arcus tangens float atan(float y_over_x) vec2 atan(vec2 y_over_x) vec3 atan(vec3 y_over_x) vec4 atan(vec4 y_over_x) Aleksander Dawid rok 208

209 Najważniejsze funkcje języka Shaderów Funkcje exponencjalne Funkcja potęgowa float pow(float x, float y) vec2 pow(vec2 x, vec2 y) vec3 pow(vec3 x, vec3 y) vec4 pow(vec4 x, vec4 y) Funkcja exponent e x float exp(float x) vec2 exp(vec2 x) vec3 exp(vec3 x) vec4 exp(vec4 x) Aleksander Dawid rok 209

210 Najważniejsze funkcje języka Shaderów Funkcje exponencjalne Funkcja logarytm naturalny log e x float log(float x) vec2 log(vec2 x) vec3 log(vec3 x) vec4 log(vec4 x) Funkcja exponent 2 x float exp2(float x) vec2 exp2(vec2 x) vec3 exp2(vec3 x) vec4 exp2(vec4 x) Aleksander Dawid rok 210

211 Najważniejsze funkcje języka Shaderów Funkcje exponencjalne Funkcja logarytm log 2 x float log2(float x) vec2 log2(vec2 x) vec3 log2(vec3 x) vec4 log2(vec4 x) Funkcja pierwiastkowania kwadratowego x float sqrt(float x) vec2 sqrt(vec2 x) vec3 sqrt(vec3 x) vec4 sqrt(vec4 x) Aleksander Dawid rok 211

212 Najważniejsze funkcje języka Shaderów Funkcje exponencjalne Funkcja odwrotnego pierwiastka 1 x float inversesqrt(float x) vec2 inversesqrt(vec2 x) vec3 inversesqrt(vec3 x) vec4 inversesqrt(vec4 x) Aleksander Dawid rok 212

213 Najważniejsze funkcje języka Shaderów Funkcje wspólne (zaokrągleń) Funkcja wartość bezwzględna float abs(float x) vec2 abs(vec2 x) vec3 abs(vec3 x) vec4 abs(vec4 x) Funkcja znakowa float sign(float x) vec2 sign(vec2 x) vec3 sign(vec3 x) vec4 sign(vec4 x) sign x = 1. 0 gdy x > gdy x = gdy x < 0 Aleksander Dawid rok 213

214 Najważniejsze funkcje języka Shaderów Funkcje wspólne (zaokrągleń) Zaokrąglenie w dół do liczby całkowitej float floor(float x) vec2 floor(vec2 x) vec3 floor(vec3 x) vec4 floor(vec4 x) Zaokrąglenie w górę do liczby całkowitej float ceil(float x) vec2 ceil(vec2 x) vec3 ceil(vec3 x) vec4 ceil(vec4 x) Aleksander Dawid rok 214

215 Najważniejsze funkcje języka Shaderów Funkcje wspólne (zaokrągleń) Część ułamkowa float fract(float x) vec2 fract(vec2 x) vec3 fract(vec3 x) vec4 fract(vec4 x) y = x floor(x) Modulo float mod(float x, float y) vec2 mod(vec2 x, vec2 y) vec3 mod(vec3 x, vec3 y) vec4 mod(vec4 x, vec4 y) Aleksander Dawid rok 215

216 Najważniejsze funkcje języka Shaderów Funkcje wspólne (zaokrągleń) Minimum float min(float x, float y) vec2 min(vec2 x, vec2 y) vec3 min(vec3 x, vec3 y) vec4 min(vec4 x, vec4 y) Maximum float max(float x, float y) vec2 max(vec2 x, vec2 y) vec3 max(vec3 x, vec3 y) vec4 max(vec4 x, vec4 y) Aleksander Dawid rok 216

217 Najważniejsze funkcje języka Shaderów Funkcje wspólne (zaokrągleń) Clamp (liczba z przedziału) float clamp(float x, float minval, float maxval) vec2 clamp(vec2 x, vec2 minval, vec2 maxval) vec3 clamp(vec3 x, vec3 minval, vec3 maxval) vec4 clamp(vec4 x, vec4 minval, vec4 maxval) Mieszanie liniowe float mix(float x, float y, float a) vec2 mix(vec2 x, vec2 y, float a) vec3 mix(vec3 x, vec3 y, float a) vec4 mix(vec4 x, vec4 y, float a) Aleksander Dawid rok 217

218 Najważniejsze funkcje języka Shaderów Funkcje wspólne (zaokrągleń) Funkcja progowa float step(float edge, float x) vec2 step(vec2 edge, vec2 x) vec3 step(vec3 edge, vec3 x) vec4 step(vec4 edge, vec4 x) Funkcja gładka dla 0.0(edge0,edge1)1.0 float smoothstep(float edge0, float edge1, float x) vec2 smoothstep(vec2 edge0, vec2 edge1, vec2 x) vec3 smoothstep(vec3 edge0, vec3 edge1, vec3 x) vec4 smoothstep(vec4 edge0, vec4 edge1, vec4 x) Aleksander Dawid rok 218

219 Najważniejsze funkcje języka Shaderów Funkcje geometryczne Funkcja długość wektora float length(float x) float length(vec2 x) float length(vec3 x) float length(vec4 x) L = x 2 + y 2 + z 2 + w 2 Funkcja odległości między dwoma punktami float distance(float p0, float p1) float distance(vec2 p0, vec2 p1) float distance(vec3 p0, vec3 p1) float distance(vec4 p0, vec4 p1) Aleksander Dawid rok 219

220 Najważniejsze funkcje języka Shaderów Funkcje geometryczne Iloczyn skalarny wektorów float dot(float x, float y) float dot(vec2 x, vec2 y) float dot(vec3 x, vec3 y) float dot(vec4 x, vec4 y) v w = v w cos (α) Iloczyn wektorowy vec3 cross(vec3 x, vec3 y) v w = e x e y e z v x w x v y w y v z w z = (e x, e y, e z ) Aleksander Dawid rok 220

221 Najważniejsze funkcje języka Shaderów Funkcje geometryczne Normalizacja wektora float normalize(float x) vec2 normalize(vec2 x) vec3 normalize(vec3 x) vec4 normalize(vec4 x) Rozpraszanie N x = 1 y 2 + z 2 + w 2 float faceforward(float N, float I, float Nref) vec2 faceforward(vec2 N, vec2 I, vec2 Nref) vec3 faceforward(vec3 N, vec3 I, vec3 Nref) vec4 faceforward(vec4 N, vec4 I, vec4 Nref) Aleksander Dawid rok 221

222 Najważniejsze funkcje języka Shaderów Funkcje geometryczne Odbicie float reflect(float I, float N) vec2 reflect(vec2 I, vec2 N) vec3 reflect(vec3 I, vec3 N) vec4 reflect(vec4 I, vec4 N) Załamanie float refract(float I, float N, float eta) vec2 refract(vec2 I, vec2 N, float eta) vec3 refract(vec3 I, vec3 N, float eta) vec4 refract(vec4 I, vec4 N, float eta) Aleksander Dawid rok 222

223 Najważniejsze funkcje języka Shaderów Funkcje macierzowe Mnożenie komponentów mat2 matrixcompmult(mat2 x, mat2 y) mat3 matrixcompmult(mat3 x, mat3 y) mat4 matrixcompmult(mat4 x, mat4 y) Aleksander Dawid rok 223

224 Najważniejsze funkcje języka Shaderów Funkcje relacji wektorów Porównanie składowych wektora x[i]<y[i] bvec2 lessthan(vec2 x, vec2 y) bvec3 lessthan(vec3 x, vec3 y) bvec4 lessthan(vec4 x, vec4 y) Porównanie składowych wektora x[i]<=y[i] bvec2 lessthanequal(vec2 x, vec2 y) bvec3 lessthanequal(vec3 x, vec3 y) bvec4 lessthanequal(vec4 x, vec4 y) Aleksander Dawid rok 224

225 Najważniejsze funkcje języka Shaderów Funkcje relacji wektorów Porównanie składowych wektora x[i]>y[i] bvec2 greaterthan(vec2 x, vec2 y) bvec3 greaterthan(vec3 x, vec3 y) bvec4 greaterthan(vec4 x, vec4 y) Porównanie składowych wektora x[i]>=y[i] bvec2 greaterthanequal(vec2 x, vec2 y) bvec3 greaterthanequal(vec3 x, vec3 y) bvec4 greaterthanequal(vec4 x, vec4 y) Aleksander Dawid rok 225

226 Najważniejsze funkcje języka Shaderów Funkcje relacji wektorów Porównanie składowych wektora x[i]==y[i] bvec2 equal(vec2 x, vec2 y) bvec3 equal(vec3 x, vec3 y) bvec4 equal(vec4 x, vec4 y) Porównanie składowych wektora x[i]!=y[i] bvec2 notequal(vec2 x, vec2 y) bvec3 notequal(vec3 x, vec3 y) bvec4 notequal(vec4 x, vec4 y) Aleksander Dawid rok 226

227 Najważniejsze funkcje języka Shaderów Funkcje relacji wektorów Prawda gdy którakolwiek ze składowych jest True bool any(bvec2 x) bool any(bvec3 x) bool any(bvec4 x) Prawda gdy wszystkie składowe zwracają prawdę bool all(bvec2 x) bool all(bvec3 x) bool all(bvec4 x) Aleksander Dawid rok 227

228 Najważniejsze funkcje języka Shaderów Funkcja przeglądanie tekstur vec4 texture2d(sampler2d sampler, vec2 coord) vec4 texture2d(sampler2d sampler, vec2 coord, float bias) Funkcja zwraca kolor texela dla danej współrzędnej tekstury. Parametr bias dotyczy wybranej MIPMAPY Aleksander Dawid rok 228

229 OpenCL Otwarty standard programowania multiprocesorów Aleksander Dawid programowanie procesorów graficznych

230 OpenCL Język tej biblioteki podobnie jak wszystkie systemy otwarte operuje na własnych typach zmiennych. cl_int, cl_float, cl_uint, cl_double, cl_long Aleksander Dawid programowanie procesorów graficznych

231 clgetplatformids clgetdeviceids clcreatecontext Strumień przetwarzania potoku OpenCL clcreatecommandqueue clcreateprogramwithsource Zwolnienie zasobów clbuildprogram clenqueuereadbuffer clcreatebuffer clenqueuendrangekernel clcreatekernel clsetkernelarg Aleksander Dawid programowanie procesorów graficznych

232 OpenCL - przygotowanie przetwarzania informacji na GPU 1. Informacja o platformie i urządzaniach cl_int clgetplatformids(cl_uint nentries, cl_platform_id *platforms, cl_uint *nplatforms) nentries spodziewana ilość plaform platforms zwraca listę identyfikatorów platform OpenCL nplatforms zwraca ilość platform Sukces: CL_SUCCESS Porażka: CL_INVALID_VALUE cl_int clgetdeviceids(cl_platform_id platform, cl_device_type device_type, cl_uint nentries, cl_device_id *devices, cl_uint *ndevices) platform identyfikator platformy device_type CL_DEVICE_TYPE_CPU, CL_DEVICE_TYPE_GPU, CL_DEVICE_TYPE_ALL nentries spodziwana ilość urządzeń devices zwraca listę identyfikatorów urządzeń. ndevices zwraca ilość urządzeń OpenCL Sukces: CL_SUCCESS Porażka: CL_INVALID_PLATFORM, CL_INVALID_DEVICE_TYPE, CL_INVALID_VALUE, CL_DEVICE_NOT_FOUND Aleksander Dawid programowanie procesorów graficznych

233 OpenCL - przygotowanie przetwarzania informacji na GPU cl_int clgetdeviceinfo(cl_device_id device, cl_device_info param_name, size_t param_value_size, void *param_value, size_t *param_value_size_ret) Device identyfikator urządzania Param_name nazwa parametru informacji Param_value_size rozmiar w bajtach parametru inforamcji Param_value wskaźnik do obszaru przechowującego informacje Param_value_size_ret zwrócony rozmiar Param_name CL_DEVICE_NAME CL_DEVICE_VENDOR CL_DEVICE_VERSION CL_DEVICE_MAX_CLOCK_FREQUENCY Aleksander Dawid programowanie procesorów graficznych

234 OpenCL - przygotowanie przetwarzania informacji na GPU 2. Utworzenie kontekstu urządzenia cl_context clcreatecontext(cl_context_properties *properties, cl_uint num_devices, const cl_device_id *devices, void *pfn_notify ( const char *errinfo, const void *private_info, size_t cb, void *user_data), void *user_data, cl_int *errcode_ret) Zbiornik grupujący dane. properties właściwości platformy, NULL = domyślne num_devices zadeklarowana ilość urządzeń devices wskźnik do list urządzeń pfn_notify funkcja zwrotna (callback function) user_data związany z funkcja zwrotną errcode_ret zwraca kod błędu Sukces: CL_SUCCESS Porażka: CL_INVALID_PLATFORM, CL_INVALID_DEVICE, CL_INVALID_VALUE, Aleksander Dawid programowanie procesorów graficznych

235 OpenCL - przygotowanie przetwarzania informacji na GPU 3. Utworzenie kolejkę poleceń na wybranym urządzeniu cl_command_queue clcreatecommandqueue(cl_context context, cl_device_id device, cl_command_queue_properties properties, cl_int *errcode_ret) context OpenCL kontext z poprzedniego kroku device identyfikator urządzenia properties właściwości kolejki poleceń errcode_ret zwraca kod błędu Sukces: CL_SUCCESS Porażka: CL_INVALID_CONTEXT, CL_INVALID_DEVICE, CL_INVALID_VALUE, CL_INVALID_QUEUE_PROPERTIES, CL_OUT_OF_HOST_MEMORY Aleksander Dawid programowanie procesorów graficznych

236 OpenCL - przygotowanie przetwarzania informacji na GPU 4. Tworzenie obiektu programu dla kontekstu cl_program clcreateprogramwithsource (cl_context context, cl_uint count, const char **strings, const size_t *lengths, cl_int *errcode_ret) Context utworzony kontekst OpenCL Count ilość kontekstów Strings Ciąg z programem źródłowym kernela Lengths Długości każdego z ciągów errcode_ret zwracany kod błędu Sukces: CL_SUCCESS Porażka: CL_INVALID_CONTEXT, CL_INVALID_VALUE, CL_OUT_OF_HOST_MEMORY Aleksander Dawid programowanie procesorów graficznych

237 OpenCL - przygotowanie przetwarzania informacji na GPU 5. Kompilacja programu cl_int clbuildprogram ( cl_program program, cl_uint num_devices, const cl_device_id *device_list, const char *options, void (*pfn_notify)(cl_program, void *user_data), void *user_data) program identyfikator programu num_devices ilość urządzeń device_list lista urządzeń Options wskaźnik do ciągu z opcjami (Optymalizacja) pfn_notify- funkcja zwrotna (callback function) user_data - związany z funkcja zwrotną Sukces: CL_SUCCESS Porażka: CL_INVALID_PROGRAM, CL_INVALID_VALUE, CL_INVALID_DEVICE, CL_COMPILER_NOT_AVAILABLE Aleksander Dawid programowanie procesorów graficznych

238 OpenCL - przygotowanie przetwarzania informacji na GPU 6. Alokacja pamięci cl_mem clcreatebuffer ( cl_context context, cl_mem_flags flags, size_t size, void *host_ptr, cl_int *errcode_ret) context OpenCL kontekst flags pole bitowe specyfikujące sposób użycia pamięci CL_MEM_READ_WRITE, CL_MEM_WRITE_ONLY, CL_MEM_READ_ONLY, CL_MEM_USE_HOST_PTR CL_MEM_ALLOC_HOST_PTR, CL_MEM_COPY_HOST_PTR size rozmiar bufora do zaalokowania host_ptr wskaźnik(adres) tego bufora errcode_ret kod błędu Sukces: CL_SUCCESS Porażka: CL_INVALID_CONTEXT, CL_INVALID_BUFFER_SIZE, CL_INVALID_HOST_PTR, CL_MEM_OBJECT_ALLOCATION_FAILURE Aleksander Dawid programowanie procesorów graficznych

239 OpenCL - przygotowanie przetwarzania informacji na GPU 7. Tworzenie kernela cl_kernel clcreatekernel ( cl_program program, const char *kernel_name, cl_int *errcode_ret) Program identyfikator programu kernel_name nazwa kernela errcode_ret zwracany kod błędu Sukces: CL_SUCCESS Porażka: CL_INVALID_PROGRAM, CL_INVALID_PROGRAM_EXECUTABLE, CL_INVALID_KERNEL_NAME, CL_INVALID_KERNEL_DEFINITION, CL_INVALID_VALUE Aleksander Dawid programowanie procesorów graficznych

240 OpenCL - przygotowanie przetwarzania informacji na GPU 8. Ustawienie argumentów cl_int clsetkernelarg ( cl_kernel kernel, cl_uint arg_index, size_t arg_size, const void *arg_value) Kernel identyfikator kernela arg_index indeks argumentu arg_size rozmiar argumentu arg_value wskaźnik do bufora pamięci Sukces: CL_SUCCESS Porażka: CL_INVALID_KERNEL, CL_INVALID_ARG_INDEX, CL_INVALID_ARG_VALUE, CL_INVALID_MEM_OBJECT, CL_INVALID_ARG_SIZE Aleksander Dawid programowanie procesorów graficznych

241 OpenCL - przygotowanie przetwarzania informacji na GPU 9. Uruchomienie kernela cl_int clenqueuendrangekernel ( cl_command_queue command_queue, cl_kernel kernel, cl_uint work_dim, const size_t *global_work_offset, const size_t *global_work_size, const size_t *local_work_size, cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event *event) command_queue kolejka poleceń Kernel kernel identyfikator work_dim ilość wymiarów określających zadanie global_work_offset na razie NULL, wprowadzony dla przyszłych wersji global_work_size lista określająca rozmiar dla każdego wymiaru local_work_size określa rozmiar grup roboczych num_events_in_wait_list określa zdarzenie na które musi czekać kernel event_wait_list - określa zdarzenie na które musi czekać kernel event identyfikator zdarzenia Aleksander Dawid programowanie procesorów graficznych

242 OpenCL - przygotowanie przetwarzania informacji na GPU 9. Uruchomienie kernela cd Sukces: CL_SUCCESS Porażka: CL_INVALID_PROGRAM_EXECUTABLE, CL_INVALID_COMMAND_QUEUE, CL_INVALID_KERNEL, CL_INVALID_CONTEXT, CL_INVALID_KERNEL_ARGS, CL_INVALID_WORK_DIMENSION, CL_INVALID_WORK_GROUP_SIZE CL_INVALID_WORK_ITEM_SIZE, CL_INVALID_GLOBAL_OFFSET CL_OUT_OF_RESOURCES, CL_MEM_OBJECT_ALLOCATION_FAILURE, CL_INVALID_EVENT_WAIT_LIST, CL_OUT_OF_HOST_MEMORY Aleksander Dawid programowanie procesorów graficznych

243 OpenCL - przygotowanie przetwarzania informacji na GPU 10. Odczytanie danych z urządzenia cl_int clenqueuereadbuffer ( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read, size_t offset, size_t cb, void *ptr, cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event *event) command_queue kolejka poleceń buffer identyfikator bufora blocking_read odczyt blokujący Offset przesunięcie w buforze cb ilość danych do odczytu ptr wskaźnik do bufora w pamięci gospodarza num_events_in_wait_list lista zdarzeń event_wait_list lista zdarzeń event - zdarzenie Aleksander Dawid programowanie procesorów graficznych

244 OpenCL - przygotowanie przetwarzania informacji na GPU 10. Odczytanie danych z urządzenia cd Sukces: CL_SUCCESS Porażka: CL_INVALID_CONTEXT, CL_INVALID_COMMAND_QUEUE, CL_INVALID_MEM_OBJECT, CL_INVALID_VALUE, CL_INVALID_EVENT_WAIT_LIST, CL_MEM_OBJECT_ALLOCATION_FAILURE, CL_OUT_OF_HOST_MEMORY Aleksander Dawid programowanie procesorów graficznych

245 OpenCL - przygotowanie przetwarzania informacji na GPU 11. Zwolnienie zasobów status = clreleasekernel(kernel); status = clreleaseprogram(program); status = clreleasememobject(inputbuffer); status = clreleasememobject(outputbuffer); status = clreleasecommandqueue(commandqueue); status = clreleasecontext(context); Sukces: CL_SUCCESS Porażka: zależna od zwalnianego zasobów Aleksander Dawid programowanie procesorów graficznych

246 OpenCL - Kernel GPU kernel void helloworld( global char* in, global char* out) { int num = get_global_id(0); out[num] = in[num] + 1; } Aleksander Dawid programowanie procesorów graficznych

247 Platformy OpenCL AMD APP SDK 3.0 Karty AMD wspierane w OpenCL od wersji Radeon HD 4000 w górę AMD kompilacja kernel void helloworld( global char* in, global char* out) { int num = get_global_id(0); out[num] = in[num] + 1; } Aleksander Dawid programowanie procesorów graficznych

248 Platformy OpenCL CUDA TOOLKIT do wersji 4.0 Wspierane karty z rdzeniami CUDA od GF 8600GTX NVIDIA kompilacja kernel void helloworld( global char* in, global char* out) { int num = get_global_id(0); out[num] = in[num] + 1; } Aleksander Dawid programowanie procesorów graficznych

249 Przykład OpenCL na AMD i NVIDIA Kod CPU kernel void helloworld( global char* in, global char* out) { int num = get_global_id(0); out[num] = in[num] + 1; } Aleksander Dawid programowanie procesorów graficznych

250 Przykład OpenCL na AMD i NVIDIA Kod GPU kernel void helloworld( global char* in, global char* out) { int num = get_global_id(0); out[num] = in[num] + 1; } Aleksander Dawid programowanie procesorów graficznych

251 Programowanie procesorów graficznych NVIDIA (rdzenie CUDA)

252 Programowanie procesorów graficznych Wprowadzenie Procesory graficzne GPU (Graphics Processing Units) stosowane są w kartach graficznych do przetwarzania grafiki komputerowej i wyświetlania jej na ekranie monitora Motorem rozwoju GPU jest rynek gier komputerowych Fotorealizm w czasie rzeczywistym Cechy GPU Przetwarzanie równoległe Ilość rdzeni > 100 (1 CPU = 8 rdzeni) Przyspieszone operacje na macierzach. Wydajność rzędu Tfps Przetwarzanie wierzchołków i pixeli Przetwarzania światła Obsługa efektów fizycznych Obsługa biblioteki OpenGL i DirectX Aleksander Dawid

253 Programowanie procesorów graficznych Naukowe obliczenia numeryczne 2 najszybsze komputery świata korzystają z kart graficznych do zwiększenia swojej mocy obliczeniowej. 1 Titan supercomputer Oak Ridge National Laboratory Układ Kepler GK rdzeni CUDA 6 GB pamięci GDDR5 384-bitowy interfejs 8,972 - GPU Tesla K20X (Architektura Kepler) Maksymalna moc obliczeniowa to 27 petaflops czyli operacji zmiennoprzecinkowych na sekundę Aleksander Dawid

254 Programowanie procesorów graficznych Naukowe obliczenia numeryczne 2 Tianhe 1a - Chiny TESLA (Fermi core) 448 CUDA Cores Tianhe 1a - Chiny 515 Gigaflops (podwójna precyzja) 14,336 procesorów Xeon X Teraflop (pojedyncza precyzja) 7,168 GPU Nvidia Tesla M2050 Maksymalna wydajność petaflops operacji zmiennoprzecinkowych na sekundę Aleksander Dawid

255 Programowanie procesorów graficznych Światowe zasoby Aleksander Dawid

256 Programowanie procesorów graficznych Wzrost wydajności Aleksander Dawid

257 Programowanie procesorów graficznych Wzrost wydajności Aleksander Dawid

258 Programowanie procesorów graficznych Obliczenia ogólnego przeznaczenia na GPU Model Cg ( C for graphics) Obliczenia wykonywane były w ramach jednostek obliczeniowych pixel shader i vertex shader. Wynik obliczeń nie dało się odczytać bezpośrednio w postaci numerycznej tylko jako zestaw pixeli na ekranie monitora. Model CUDA (Compute Unified Device Architecture) Obliczenia wykonywane są na wszystkich dostępnych rdzeniach. Wynik obliczeń można odebrać w postaci numerycznej (terminal) Cechy CUDA Wielowątkowość Wielozadaniowość Programowanie w językach wysokiego poziomu Aleksander Dawid

259 Programowanie procesorów graficznych Architektura CUDA Model pamięci Pamięć lokalna dostępna tylko dla wątku (bardzo szybka) Pamięć dzielona dostępna tylko dla wszystkich wątków w bloku (bardzo szybka) Pamięć globalna dostępna dla wszystkich wątków (raczej wolna). Aleksander Dawid

260 Programowanie procesorów graficznych Architektura CUDA RAM CPU >= GPU Większa ilość pamięci na karcie zwiększa prędkość obliczeń Wspierane języki programowania. Dodatkowo istniej możliwość programowania CUDA w językach JAVA i Python Aleksander Dawid

261 Programowanie procesorów graficznych Programowanie CUDA C Kompilator: nvcc Dostęþny jest w pakiecie CUDA toolkit dla różnych systemów operacyjnych takich jak Windows, Linux, Mac. Pełne wsparcie dla standardu ANSI C z elementami C++ CUDA w wersji 1.0 dostępne jest już dla kart NVIDA GeForce 8600 Kod programu Kod CPU Kod GPU Aleksander Dawid

262 Programowanie procesorów graficznych Programowanie CUDA C Zadania Kod CPU Informacja o sprzęcie Inicjalizacja pamięci Operacje I/O CPU->GPU, GPU->CPU Zwalnianie pamięci Zadania Kod GPU Sterowanie programem Pamięci lokalne i dzielone Obliczenia numeryczne Synchronizacja wątków Program oddaje sterowanie do GPU i czeka na wynik obliczeń. Wykonane może to być w sposób synchroniczny lub asynchroniczny. GPU rozwiązuje zadanie na wszystkich dostępnych rdzeniach równolegle. Kod programu musi być specjalnie urównoleglony. Aleksander Dawid

263 Programowanie procesorów graficznych Programowanie CUDA C Wymagania systemowe Windows XP/VISTA/7/8/10 CUDA developer driver, CUDA toolkit, MS Visual Studio C++ Linux: nowsze dystrybucje. CUDA developer driver, CUDA toolkit, gcc4.4 Dodatkowo dla wszystkich systemów GPUComputingSDK, w którym są przykłady programów CUDA. Działanie tych programów jest gwarancją prawidłowej instalacji sterowników CUDA w systemie. Uwaga!!! WINDOWS VISTA/7 resetuje karte po braku odpowiedzi w przeciągu 90 s. Warto ten czas przedłużyć gdy nie będziemy korzystać z grafiki. Aleksander Dawid

264 Programowanie procesorów graficznych Kod CPU (informacja o zainstalowanej karcie) #include <stdio.h> #include <cutil.h> W pliku nagłówkowym cutil.h zawarte są informacje o wszystkich nagłówkach CUDA. Aby zastosować tą funkcje w systemi musi być dostępna biblioteka libcutil_x86_64.a (Linux64), która znajduje się w GPUComputingSDK. void PrintDevicesInformation() { int devicecount,nrdev,nmulproc; cudagetdevicecount(&devicecount); printf("number of CUDA devices: %d\n",devicecount); for(nrdev = 0; nrdev < devicecount; nrdev++) { cudadeviceprop deviceprop; cudagetdeviceproperties(&deviceprop, nrdev); printf("device %d: %s\n", nrdev, deviceprop.name); printf("maxthreadsperblock: %d\n", deviceprop.maxthreadsperblock); nmulproc=deviceprop.multiprocessorcount; printf("multiprocessorcount: %d\n", nmulproc); printf("computemode: %d\n", deviceprop.computemode); printf("sharedmemperblock: %ld\n", deviceprop.sharedmemperblock); } } Aleksander Dawid

265 Programowanie procesorów graficznych Pola struktury cudadeviceprop int canmaphostmemory // Urządzenie pozwala na mapowanie pamięci RAM int clockrate // Częstotliwość zegara w khz int computemode // cudacomputemodedefault - przetwarzanie wielowątkowe załączone // cudacomputemodeexclusive tylko jeden wątek // cudacomputemodeprohibited żaden wątek (CUDA wyłaczone) int concurrentkernels // Urządzenie uruchamia wiele jąder (kernel) konkurencyjnie int deviceoverlap // Urządzenie konkurencyjnie kopiuje i wykonuje jądra. int ECCEnabled // Urządzenie wspiera ECC int integrated // Czy urządzenie jest zintegrowane int kernelexectimeoutenabled // Czy są ogranicznia czasowe na wykonanie kernela int major // Główna wspierana wersja CUDA Aleksander Dawid

266 Programowanie procesorów graficznych Pola struktury cudadeviceprop int maxgridsize [3] // Maksymalny rozmiar macierzy obliczeniowej w każdym kierunku dim1 x dim2 x dim3 int maxtexture1d // Maksymalny rozmiar tekstury jednowymiarowej int maxtexture2d [2] // Maksymalny rozmiar tekstury dwuwymiarowej int maxtexture2darray [3] // Maksymalny rozmiar macierzy tekstury dwuwymiarowej int maxtexture3d [3] // Maksymalny rozmiar tekstury trójwymiarowej int maxthreadsdim [3] // Maksymalny rozmiar każdego wymiaru w bloku wątków int maxthreadsperblock // Maksymalna ilość wątków w bloku size_t mempitch // Maksymalny rozmiar pakietu w bajtach dozwolony przy kopiowaniu int minor // Numer 1.x wersji CUDA wspieranej Aleksander Dawid

267 Programowanie procesorów graficznych Pola struktury cudadeviceprop int multiprocessorcount // Ilość multiprocesorów w urządzeniu char name [256] // Ciąg ASCI identyfikujący urządzenie int pcibusid // Identyfikator PCI Bus urządzenia int pcideviceid // PCI ID urządzenia int regsperblock // ilość rejestrów 32-bit na blok size_t sharedmemperblock // Pamięć dzielona dostępna na blok [bajty] size_t surfacealignment // Wymagania dotyczące wyrównania powierzchni int tccdriver // 1 Jeżeli TESLA używa sterownika TCC; w przeciwnym razie 0 size_t texturealignment // Wymagania dotyczące wyrównania tekstury size_t totalconstmem // Constan memory dostępna na urządzeniu w bajtach size_t totalglobalmem // Globalna pamięć dostępna na urządzeniu int warpsize // Wielkość Warp w wątkach Aleksander Dawid

268 Programowanie procesorów graficznych Kod CPU (informacja o zainstalowanej karcie) int main(int argc, char* argv[]) { PrintDevicesInformation(); return 0; } Kompilacja gcc4.4 UBUNTU > nvcc program.cu -lcudart pathtolib/libcutil_x86_64.a -o program Wynik działania Number of CUDA devices: 1 Device 0: Quadro FX 5800 maxthreadsperblock: 512 multiprocessorcount: 30 computemode: 0 sharedmemperblock: Często stosowane rozszerzenie.cu zarówno w Linux jak i w Windows Aleksander Dawid

269 Kwalifikatory Typy funkcji host - oznacza funkcję która będzie wykonywana na CPU device - oznacza że funkcja będzie wykonywana na GPU global -funkcja globalna, wywoływana z CPU(host) i GPU(device) CUDA 3.x host device host device func() { #if CUDA_ARCH >= 500 // Device code path for compute capability 5.x #elif CUDA_ARCH >= 300 // Device code path for compute capability 3.x #elif CUDA_ARCH >= 200 // Device code path for compute capability 2.x #elif!defined( CUDA_ARCH ) // Host code path #endif } Aleksander Dawid

270 Kwalifikatory Typy zmiennych constant - oznacza stałą zadeklarowaną w GPU device - oznacza zmienną wewnątrz GPU shared - razem z kwalifikatorem device oznacza zmienną która rezyduje w pamięci dzielonej bloku i istnieje tak długo jak istnieje blok. Dostępna jest tylko dla wątków z bloku. Aleksander Dawid

271 Zarządzanie urządzeniami Wybór urządzenia najlepiej odpowiadającego wymaganiom obliczeniowym host cudaerror_t cudachoosedevice ( int* device, const cudadeviceprop* prop ) device urządzenie wybrane do obliczeń prop wymagania względem urządzenia. Returns cudasuccess, cudaerrorinvalidvalue Liczba dostępnych urządzeń CUDA host device cudaerror_t cudagetdevicecount ( int* count ) count liczba dostępnych urządzeń CUDA Aleksander Dawid

272 Zarządzanie urządzeniami Funkcja zwraca urządzenie id urządzenia na którym trwają obliczenia. host device cudaerror_t cudagetdevice ( int* device ) device urządzenie wybrane do obliczeń Ustawienie urządzenia na którym będą wykonywane obliczenia. host cudaerror_t cudasetdevice (int device) device urządzenie wybrane do obliczeń Resetowanie wszystkich ustawień w urządzeniu, zamykanie wątków obliczeniowych. host cudaerror_t cudadevicereset (void) Aleksander Dawid

273 Zarządzanie urządzeniami Czekaj aż wszystkie urządzenia przestaną liczyć. host device cudaerror_t cudadevicesynchronize ( void ) Ustaw flagę urządzenia host cudaerror_t cudasetdeviceflags ( unsigned int flags ) flags wskaźnik do ustawionej flagi na komputerze. Pobierz flagę urządzenia host cudaerror_t cudagetdeviceflags ( unsigned int* flags ) flags wskaźnik do ustawionej flagi na komputerze. Aleksander Dawid

274 Obsługa błędów Zwracanie nazwy błędu w postaci ciągu znaków. host device const char* cudageterrorname ( cudaerror_t error ) error identyfikator błędu. Zwracanie opisu błędu w postaci ciągu znaków. host device const char* cudageterrorstring ( cudaerror_t error ) error identyfikator błędu. Funkcja zwraca numer ostatniego błędu host device cudaerror_t cudagetlasterror ( void ) Aleksander Dawid

275 Obsługa zdarzeń (Event Management) Utwórz obiekt zdarzenie host cudaerror_t cudaeventcreate ( cudaevent_t* event ) event obiekt zdarzenie. Utwórz obiekt zdarzenie i ustaw dla niego flagę. host device cudaerror_t cudaeventcreatewithflags ( cudaevent_t* event, unsigned int flags ) Usuń obiekt zdarzenie host device cudaerror_t cudaeventdestroy ( cudaevent_t event ) Aleksander Dawid

276 Obsługa zdarzeń (Event Management) Oblicz czas pozostały pomiędzy zdarzeniami host cudaerror_t cudaeventelapsedtime ( float* ms, cudaevent_t start, cudaevent_t end ) Prześlij status zdarzenia host cudaerror_t cudaeventquery ( cudaevent_t event ) Nagraj zdarzenie host device cudaerror_t cudaeventrecord ( cudaevent_t event, cudastream_t stream = 0 ) Czekaj dopuki jakieś zdarzenie się wydarzy host cudaerror_t cudaeventsynchronize ( cudaevent_t event ) Aleksander Dawid

277 Programowanie procesorów graficznych Kod CPU (CPU->GPU) #define real float real* R; size_t size; void CPUMemAlloc() { size = 16*sizeof(real); // 16 liczb typu real R = (real*)malloc(size); memset(r,0,size); } Funkcja CPUMemAlloc alokuje pamięć dla 16 liczb typu real czyli float real* d_r; void GPUMemAlloc() { cudamalloc((void**)&d_r, size); } Funkcja GPUMemAlloc alokuje pamięć na karcie graficznej dla 16 liczb typu real Aleksander Dawid

278 Programowanie procesorów graficznych Kod CPU (CPU->GPU) void CopyCPUToGPU() { cudamemcpy(d_r, R, size, cudamemcpyhosttodevice); } Funkcja kopiuje size bloków pamięci z komputera na kartę graficzną Host komputer z CPU Device karta graficzna void CopyGPUToCPU() { cudamemcpy(r, d_r, size, cudamemcpydevicetohost); } Odwrotna operacja W operacjach tych brakuje obsługi wyjątków, które mogą wystąpić z różnych przyczyn. Funkcja cudagetlasterror()podaje numer ostatniego błędu. Aleksander Dawid

279 Programowanie procesorów graficznych Kod CPU (CPU->GPU) int main(int argc, char* argv[]) { CPUMemAlloc(); GPUMemAlloc(); R[0]=5; CopyCPUToGPU(); CopyGPUToCPU(); printf("r[0]=%f\n",r[0]); return 0; } Brakuje operacji wykonywanych na karcie graficznej Musimy stworzyć tzw. Kernel, który będzie wykonywany na GPU. Aleksander Dawid

280 Programowanie procesorów graficznych Kod CPU (Inicjalizacja Kernela GPU) int threadsperblock, blockspergrid, sharedsize; void InitKernel() { threadsperblock = 16; //Tyle samo wątków w bloku ile liczb mamy do //przeliczenia blockspergrid = 1; sharedsize = size; //Szybka pamięć dzielona na 16 liczb real } Każda karta graficzna ma inną maksymalną ilość wątków w jednym bloku. Wartość ta waha się między 128 a Tutaj blok został ustalony na 16 wątków. Ilość bloków w macierzy obliczeniowej też zależy od karty, tutaj ustalamy 1 blok. Teraz możemy już pisać program dla GPU Aleksander Dawid

281 Programowanie procesorów graficznych Kod GPU (Przemnożenie macierzy przez dwa) global void MultByTwo(real* R){ extern shared real rs[]; unsigned int id = threadidx.x; R[id]=R[id]*2; } Główna procedura w GPU tworzona jest przez dyrektywę global. shared oznacza pamięć dostępną dla całego bloku. int main(int argc, char* argv[]) { CPUMemAlloc(); GPUMemAlloc(); R[0]=5; CopyCPUToGPU(); InitKernel(); MultByTwo<<<blocksPerGrid, threadsperblock, sharedsize>>>(d_r); CopyGPUToCPU(); printf( R[0]=%f\n,R[0]); return 0; } Aleksander Dawid

282 Programowanie procesorów graficznych Przetwarzanie Kod sekwencyjny Wielokrotne wywoływanie kodu równoległego dla tego samego zestawu danych Kod równoległy kernel0<<<>>>() Kod sekwencyjny Kod równoległy kernel1<<<>>>() Aleksander Dawid

283 Programowanie procesorów graficznych Kod GPU (Sumowanie elementów macierzy) global void SumM(real* R){ extern shared real rs[]; unsigned int id = threadidx.x; rs[id]=r[id]; syncthreads(); if(id==0){ real SUM=0; for(int i=0;i<16;i++){ SUM+=rS[i]; } R[0]=SUM; } } int main(int argc, char* argv[]) { CPUMemAlloc(); GPUMemAlloc(); R[0]=5;R[1]=2;R[2]=4; CopyCPUToGPU(); InitKernel(); SumM<<<blocksPerGrid, threadsperblock, sharedsize>>>(d_r); CopyGPUToCPU(); printf( R[0]=%f\n,R[0]); return 0; } Aleksander Dawid

284 Programowanie procesorów graficznych Kod GPU (Redukcja 1) W poprzednim programie do sumowania liczb z każdego wątku użyte został tylko jeden wątek o identyfikatorze 0 global void SumReducto(real* R){ extern shared real rs[]; unsigned int id = threadidx.x; rs[id]=r[id]; syncthreads(); for(unsigned int s=1; s < blockdim.x; s *= 2) { if (id % (2*s) == 0) { rs[id] += rs[id + s]; } syncthreads(); } if(id == 0) R[0] = rs[0]; } Aleksander Dawid

285 Programowanie procesorów graficznych Kod GPU (Redukcja 1) Aleksander Dawid

286 Programowanie procesorów graficznych Kod GPU (Redukcja 2) Operacja modulo (%) jest bardzo wolna i wymaga zmiany. global void SumReducto2(real* R){ extern shared real rs[]; unsigned int id = threadidx.x; rs[id]=r[id]; syncthreads(); for(unsigned int s=1; s < blockdim.x; s *= 2) { int index = 2 * s * id; if (index < blockdim.x) { rs[index] += rs[index + s]; } syncthreads(); } if(id == 0) R[0] = rs[0]; } Aleksander Dawid

287 Programowanie procesorów graficznych Kod GPU (Obliczanie numeryczne całki metoda trapezów) Polega na sumowaniu pól trapezów pod krzywą Aleksander Dawid

288 Programowanie procesorów graficznych Kod GPU (Obliczanie numeryczne całki metoda trapezów) global void Trapez(real* Y, real* R){ extern shared real rs[]; unsigned int id = threadidx.x; rs[id]=y[id]; syncthreads(); if(id<blockdim.x-1){ real field; field=(rs[id] + 0.5* abs(rs[id]-rs[id+1]))*dxgpu; syncthreads(); rs[id]=field; } for(unsigned int s=1; s < blockdim.x; s *= 2) { int index = 2 * s * id; if (index < blockdim.x) { rs[index] += rs[index + s]; } syncthreads(); } if(id == 0) R[0] = rs[0]; } Aleksander Dawid

289 Programowanie procesorów graficznych Kod GPU (Obliczanie numeryczne całki metoda trapezów) constant real dxgpu=0; int main(int argc, char* argv[]) { CPUMemAlloc(); GPUMemAlloc(); InitKernel(); // threadsperblock=128 dx= ; //1/128 cudamemcpytosymbol(dxgpu, &dx, sizeof(real)); for(int i=0;i<threadsperblock;i++){ Y[i]=sqrt(1-(i*dx)*(i*dx)); } CopyCPUToGPU(); Trapez<<<blocksPerGrid, threadsperblock, sharedsize>>>(d_y, d_r); CopyGPUToCPU(); printf( R[0]=%f\n,R[0]); return 0; } Aleksander Dawid

290 Aleksander Dawid 290 CUDA-Układ wielu cząstek Numeryczne rozwiązywanie równań ruchu bazuje na rozwinięciu szeregu Taylora wokół pewnej chwili czasowej. Postać ogólna szeregu Taylora i j

291 Aleksander Dawid 291 Układ wielu cząstek Śledzenie trajektorii cząstki w odpowiednich przedziałach czasowych Algorytm velocity Verlet

292 V Ar-Ar [10-21 J] Układ wielu cząstek Potencjał Lennarda-Jonesa Parametry zależne od typu atomu r [A] Siły - potencjł symetryczny Aleksander Dawid 292

293 Aleksander Dawid 293 Siłę liczymy jako gradient potencjału. Siła jest wektorem o 3 składowych F(x,y,z) Obliczanie siły - Gradient potencjału Lennarda-Jonesa

294 Aleksander Dawid 294 Obliczanie siły kod sekwencyj for(i=0;i<n-1;i++) //F[i],R[i] struktury przechowujące { // siły i położenia poszczególnych for(j=i+1;j<n;j++) // atomów { Rxij=R[i].x - R[j].x; Ryij=R[i].y - R[j].y; Rzij=R[i].z - R[j].z; Rijsqr2 = Rxij*Rxij + Ryij*Ryij + Rzij*Rzij; Rij = sqrt(rijsqr2); Rijs2 = (Sigma*Sigma)/Rijsqr2; Rijap = Rijs2*Rijs2*Rijs2; Rijrp = 2*Rijs2*Rijs2*Rijs2*Rijs2*Rijs2*Rijs2; FXij = (ALJ*Rxij*(Rijrp-Rijap))/Rijsqr2; FYij = (ALJ*Ryij*(Rijrp-Rijap))/Rijsqr2; FZij = (ALJ*Rzij*(Rijrp-Rijap))/Rijsqr2; FXji = -FXij; FYji = -FYij; FZji = -FZij; F[i].x += FXij; F[i].y += FYij; F[i].z += FZij; F[j].x += FXji; F[j].y += FYji; F[j].z += FZji; } }

295 Aleksander Dawid 295 Obliczanie siły kod CUDA global void Force(real4* Rvect,real4* Fvect) { extern shared real4 rpos[]; //Pamięć dzielona unsigned int gid = mul24(blockdim.x,blockidx.x) + threadidx.x; if(gid>gn) return; int i,tile; real4 mpos; real3 f=make_real3(0.0f,0.0f,0.0f); mpos=rvect[gid]; for (i = 0, tile = 0; i < gn; i += gp, tile++) { int bli = tile * blockdim.x; int idx = bli + threadidx.x; //kopiowania porcji położeń do pamięci dzielonej rpos[threadidx.x] = Rvect[idx]; syncthreads(); f=calcforcetail(bli,gid,mpos,f); syncthreads(); } // Zapis siły w zmiennej globalnej Fvect[gid]=make_real4(f.x,f.y,f.z,0.0f); }

296 Aleksander Dawid 296 Obliczanie siły kod CUDA Obliczanie siły na i-te centrum odziaływania 256 wątków 256 wątków 256 wątków Kopiuj położenia Pamięć dzielona Przesuń do następnego bloku Oblicz w pojedynczym wątku odległość między i-tym atomem a położeniemi atomów zapisanym w pamięci dzielonej bloku.

297 Aleksander Dawid 297 Obliczanie siły- sumowanie par w pamięci dzielonej device real3 CalcForceTail(int bli,unsigned int gbli,real4 r,real3 f) { int i; extern shared real4 rpos[]; for(i=0;i<blockdim.x;i++){ } return f; } if( bli+i!= gbli){ f=calcpairs(r, rpos[i], f); }

298 Aleksander Dawid 298 Obliczanie siły między i-tym a j-tym atomem device real3 CalcPairs(real4 ri, real4 rj, real3 f) { real R2S,InvR2, Rijap,Rijrp,RP; real4 Rij; Rij.x = ri.x - rj.x; Rij.y = ri.y - rj.y; Rij.z = ri.z - rj.z; Rij.w = Rij.x*Rij.x + Rij.y*Rij.y + Rij.z*Rij.z; InvR2=1.0f/Rij.w; R2S=SGM2*InvR2; Rijap=R2S*R2S*R2S; Rijrp=2*Rijap*Rijap; RP=EPS24*(Rijrp-Rijap)*InvR2; f.x += RP*Rij.x; f.y += RP*Rij.y; f.z += RP*Rij.z; return f; }

299 Aleksander Dawid 299 Rozwiązywanie równań ruch (algorytm Velocity Verlet) Aby nie składowąć starych przyspieszeń, algorytm dzieli się na dwa kroki global void IntegrateHalf(real4* Rvect,real4* Vvect,real4* Fvect) { int idx = mul24(blockdim.x,blockidx.x) + threadidx.x; if(idx>gn) return; real4 dr; real3 f=make_real3(fvect[idx].x,fvect[idx].y,fvect[idx].z); real3 v=make_real3(vvect[idx].x,vvect[idx].y,vvect[idx].z); real3 r=make_real3(rvect[idx].x,rvect[idx].y,rvect[idx].z); dr.x = v.x*gdt + f.x*gimass*gdt; dr.y = v.y*gdt + f.y*gimass*gdt; dr.z = v.z*gdt + f.z*gimass*gdt; r.x += dr.x; r.y += dr.y; r.z += dr.z; v.x += f.x*gimass; v.y += f.y*gimass; v.z += f.z*gimass; Rvect[idx]=make_real4(r.x,r.y,r.z,0.0f); Vvect[idx]=make_real4(v.x,v.y,v.z,0.0f); syncthreads(); }

300 Aleksander Dawid 300 Rozwiązywanie równań ruch (algorytm Velocity Verlet) Aby nie składowąć starych przyspieszeń, algorytm dzieli się na dwa kroki global void IntegrateFull(real4* Vvect,real4* Fvect) { unsigned int idx = mul24(blockdim.x,blockidx.x) + threadidx.x; if(idx>gn) return; real3 f=make_real3(fvect[idx].x,fvect[idx].y,fvect[idx].z); real3 v=make_real3(vvect[idx].x,vvect[idx].y,vvect[idx].z); v.x += f.x*gimass; v.y += f.y*gimass; v.z += f.z*gimass; Vvect[idx]=make_real4(v.x,v.y,v.z,1.0f); }

301 Aleksander Dawid 301 Rozwiązywanie równań ruch (algorytm Velocity Verlet) t Położenia początkowe t+δt Nowe położenia Każdy atom skojarzony jest z jednym wątkiem Cząstka jest jednostką obliczeniową

302 Aleksander Dawid 302 Rozwiązywanie równań ruch (algorytm Velocity Verlet) //Inicjalizacja for(t=0;t<time;t++) { IntegrateHalf<<<blocksPerGrid,threadsPerBlock,sharedSize>>>(d_R,d_V,d_F); Force<<<blocksPerGrid, threadsperblock, sharedsize>>>(d_r,d_f); IntegrateFull<<<blocksPerGrid, threadsperblock, sharedsize>>>(d_v,d_f); ReadTrajectory<<<blocksPerGrid, threadsperblock>>>(d_r,d_traj,item); item+=n; }

303 Aleksander Dawid 303 Zapis trajektorii do bufora w pamięci globalnej global void ReadTrajectory(real4* Rvect,real4* Traj, int item) { unsigned int idx = mul24(blockdim.x,blockidx.x) + threadidx.x; if(idx>gn) return; real3 r=make_real3(rvect[idx].x,rvect[idx].y,rvect[idx].z); } Traj[item+idx]=make_real4(r.x,r.y,r.z,idx);

304 Stabilność numeryczna Aleksander Dawid 304

305 Przyśpieszenie w stosunku do CPU dla liczb podwójnej precyzji Aleksander Dawid 305

306 Niektóre wyniki Aleksander Dawid 306

307 Programowanie procesorów graficznych NEXT TECHNOLOGY Aleksander Dawid programowanie procesorów graficznych