Sprawozdanie z ćwiczeń laboratoryjnych z przedmiotu Grafika komputerowa

Imię i nazwisko:	Grupa szkoleniowa:	Data:	Prowadzący zajęcia:
Andrzej Sobolewski	I7X6S1	5.12.2008	dr inż. Marek Salamon
Ocena:

I. Treść zadania:

Zadanie 16

Wykorzystując biblioteki OpenGL i GLUT napisać program przedstawiający perspektywiczny obraz obiektu o następujących parametrach:

1. Typ obiektu: sfera o zmiennej parzystej liczbie podziałów pionowych i poziomych,

2. Właściwości materiału nr 1: zielony błyszczący (widziany w białym świetle),

3. Właściwości materiału nr 2: biały matowy (widziany w białym świetle),

4. Sposób przyporządkowania materiałów do obiektu zgodnie ze wzorem: pasy pionowe z uwzględnieniem podziałów pionowych.

Obiekt należy oświetlić dwoma źródłami światła o następujących parametrach:

Źródło nr 1:

- typ: reflektor (ang. spot),

- kolor: żółty,

- natężenie: 0.8,

- kąt odcięcia: 30^o,

- położenie: zmienne po orbicie kołowej o środku w punkcie S(0,0,0) z możliwością interaktywnej zmiany następujących parametrów:

o promienia orbity,

o kąta nachylenia orbity do osi OX,

o kąta nachylenia orbity do osi OZ,

- kierunek świecenia: na obiekt.

Źródło nr 2:

- typ: kierunkowe,

- kolor: niebieski,

- natężenie: 0.6,

- położenie: stałe w punkcie P(-10,10, 10) układu współrzędnych obserwatora.

- kierunek świecenia: na obiekt.

Program powinien umożliwiać:

a) interaktywne, niezależne włączanie i wyłączanie źródeł światła;

b) interaktywną zmianę liczby podziałów pionowych i poziomych bryły;

c) interaktywną zmianę położenia obserwatora poprzez podanie następujących parametrów:

- odległości obserwatora od środka układu współrzędnych sceny;

- kąta obrotu wokół osi OY w zakresie [0^o, 360^o] z krokiem 1^o.

Oświetlony obiekt powinien zawsze znajdować się w centralnej części okna.

II. Sposób rozwiązania zadania:

Program przedstawiający perspektywiczny obraz obiektu zaczniemy od zdefiniowania

właściwości materiałów i źródeł światła, a także od przygotowania funkcji które będą

odpowiedzialne za włączanie poszczególnych świateł.

Dla pierwszego materiału o kolorze zielonym błyszczącym ustawiliśmy następujące parametry:

GLfloat param_materialu1[5][4] =

{

{ 0.0, 1.0, 0.0, 1.0 }, // [0] wspolczynnik odbicia swiatla otoczenia

{ 0.0, 1.0, 0.0, 1.0 }, // [1] wspolczynnik odbicia swiatla rozproszonego

{ 1.0, 1.0, 1.0, 1.0 }, // [2] wspolczynnik odbicia swiatla lustrzanego

{ 10.0, 0.0, 0.0, 0.0 }, // [3] polysk

{ 0.0, 0.0, 0.0, 1.0} // [4] kolor swiatla emitowanego

};

Można zauważyć, że najważniejsze wartości które odpowiadają za kolor materiału są

umieszczone we współczynnikach odbicia światła otoczenia, światła rozproszonego i

lustrzanego, natomiast aby nasz materiał się błyszczał ustawiamy pierwszą wartość połysku

na 10.

Dla materiału białego matowego w podobny sposób definiujemy wartości

połysku i poszczególnych współczynników światła tak aby otrzymać konkretny kolor:

GLfloat param_materialu2[5][4] =

{

{ 1.0, 1.0, 1.0, 1.0}, // [0] wspolczynnik odbicia swiatla otoczenia

{ 1.0, 1.0, 1.0, 1.0}, // [1] wspolczynnik odbicia swiatla rozproszonego

{ 0.0, 0.0, 0.0, 1.0}, // [2] wspolczynnik odbicia swiatla lustrzanego

{ 0.0, 0.0, 0.0, 0.0}, // [3] polysk

{ 0.0, 0.0, 0.0, 1.0} // [4] kolor swiatla emitowanego

};

Jak można zauważyć w powyższym kodzie, całość sprowadziła się do utworzenia dwóch tablic dwuwymiarowych, które zawierają odpowiednio ustawione składowe RGBA poszczególnych parametrów. Składowe pierwszego parametru określają stopień odbicia światła otaczającego, drugiego parametru - stopień rozproszenia światła rozproszonego, trzeciego parametru - stopień odbicia światła lustrzanego, zaś składowe RGBA parametru piątego określają światło emitowane przez obiekt, które w przypadku powyższych materiałów nie istnieje, czyli materiał nie jest emitujący.

Teraz przejdziemy do napisania właściwości poszczególnych źródeł światła. Zgodnie z treścią zadania dla źródła nr 1 odpowiednie wartości składowych RGBA trzech pierwszych wierszy naszej tablicy ustawiamy dla koloru żółtego na wartość 0.8, dzięki czemu otrzymujemy natężenie równe 0.8. Jest to światło reflektora w którym kąt odcięcia jest równy 30^o, więc taką wartość ustawiamy w wierszu szóstym.

GLfloat param_swiatla1[10][4] =

{

{0.8, 0.8, 0.0, 1.0}, // [0] otoczenie

{0.8, 0.8, 0.0, 1.0}, // [1] rozproszenie

{0.8, 0.8, 0.0, 1.0}, // [2] lustrzane

{5.0, 0.0, 0.0, 1.0}, // [3] polozenie

{0.0, 0.0, -1.0, 0.0}, // [4] kierunek swiecenia

{ 0.0, 0.0, 0.0, 0.0}, // [5] tlumienie katowe swiatla

{ 30.0, 0.0, 0.0, 0.0}, // [6] kat odciecia swiatla

{1.0, 0.0, 0.0, 0.0}, // [7] stale tlumienie

{0.0, 0.0, 0.0, 0.0}, // [8] tlumienie liniowe

{0.0, 0.0, 0.0, 0.0} // [9] tlumienie kwadratowe

};

W analogiczny sposób ustawiamy parametry źródła światła nr 2 z tym wyjątkiem, że jest

to światło kierunkowe gdzie nie ma zdefiniowanego kąta odcięcia, więc ustawiamy je na

180^o, aby oświetlał w całym swoim zasięgu z położenia w punkcie P(-10,10,10), które również musimy ustawić w wierszu trzecim.

GLfloat param_swiatla2[10][4] =

{

{0.0, 0.0, 0.6, 1.0}, // [0] otoczenie

{0.0, 0.0, 0.6, 1.0}, // [1] rozproszenie

{0.0, 0.0, 0.6, 1.0}, // [2] lustrzane

{-10.0, 10.0, 10.0, 0.0}, // [3] polozenie

{10.0, -10.0, -10.0, 0.0}, // [4] kierunek swiecenia

{0.0, 0.0, 0.0, 0.0}, // [5] tlumienie katowe swiatla

{180.0, 0.0, 0.0, 0.0}, // [6] kat odciecia swiatla

{0.0, 0.0, 0.0, 0.0}, // [7] stale tlumienie

{0.0, 0.0, 0.0, 0.0}, // [8] tlumienie liniowe

{0.0, 0.0, 0.0, 0.0} // [9] tlumienie kwadratowe

};

Kolejną czynnością było napisanie funkcji, które będą korzystały ze zdefiniowanych materiałów w celu ustawienia ich w odpowiednim momencie modelowania obiektu. Funkcje te przedstawiają się następująco:

void DefiniujMaterial(int w)

{

if (w==0)

{

glMaterialfv(GL_FRONT, GL_AMBIENT, material[0]);

glMaterialfv(GL_FRONT, GL_DIFFUSE, material[1]);

glMaterialfv(GL_FRONT, GL_SPECULAR, material[2]);

glMaterialfv(GL_FRONT, GL_SHININESS, material[3]);

glMaterialfv(GL_FRONT, GL_EMISSION, material[4]);

}

if (w==1)

{

glMaterialfv(GL_FRONT, GL_AMBIENT, material2[0]);

glMaterialfv(GL_FRONT, GL_DIFFUSE, material2[1]);

glMaterialfv(GL_FRONT, GL_SPECULAR, material2[2]);

glMaterialfv(GL_FRONT, GL_SHININESS, material2[3]);

glMaterialfv(GL_FRONT, GL_EMISSION, material2[4]);

}

}

Ważnym elementem modelu oświetlenia przyjętego w bibliotece OpenGL jest opis właściwości materiałów, czyli ich sposób zachowania się ze względu na poszczególne rodzaje światła. Do ustawiania parametrów materiału służy funkcja glMaterialfv(x,y,z). Argument x określa do której strony obiektu odnosi się definiowany parametr. Może on przyjmować wartości GL_FRONT, GL_BACK, GL_FRONT_AND_BACK.

Argument y określa modyfikowany parametr. Może przyjmować:

- GL_AMBIENT - określa w jakim stopniu obiekt odbija światło otoczenia. Definiują go cztery wartości RGBA,

- GL_DIFUSSE - określa jaka ilość światła padającego na obiekt ulega na jego powierzchni rozproszeniu, czyli po odbiciu rozchodzi się równomiernie we wszystkich kierunkach, parametr ten w głównej mierze decyduje o kolorze obiektu

- GL_AMBIENT_AND_DIFUSSE - posługując się tym parametrem można jednocześnie ustawić te same wartości parametrów GL_AMBIENT i GL_DIFUSSE

- GL_SPECULAR - określa jaka ilość światła odbija się od powierzchni obiektu w sposób lustrzany, czyli pod kątem padania. Kolor światła odbitego w ten sposób od rzeczywistych obiektów jest na ogół taki jako kolor źródła

- GL_SHININESS - definiuje go pojedyncza wartość od 0 do 128 określająca w jakim stopniu kąt, pod jakim obserwator widzi powierzchnię, musi być zgodny z kątem lustrzanego odbicia od niej promieni świetlnych, aby widoczny był efekt odbłysku

- GL_EMISSION - określa natężenie światła emitowanego przez obiekt

Następnym krokiem była realizacja funkcji ustawiających wyżej zdefiniowane źródła światła. Aby móc wykonywać operacje związane z oświetleniem sceny, należy umieścić w kodzie wywołanie funkcji glEnable(GL_LIGHTING); Każde światło należy oddzielnie włączyć wywołując funkcję glEnable(GL_LIGHTx); gdzie x to numer światła. Na potrzeby tego zadania w kodzie programu wywołuję tą funkcję dwa razy dla x=0 i x=1.

void WlaczOswietlenie(void)

{

// Odblokowanie oswietlenia

glEnable(GL_LIGHTING);

// Odblokowanie zrodla swiatla nr 1

if (zrodlo1 == 1){

glEnable(GL_LIGHT0);

glLightfv(GL_LIGHT0, GL_AMBIENT, swiatlo1[0]);

glLightfv(GL_LIGHT0, GL_DIFFUSE, swiatlo1[1]);

glLightfv(GL_LIGHT0, GL_SPECULAR, swiatlo1[2]);

glLightfv(GL_LIGHT0, GL_POSITION, swiatlo1[3]);

glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, swiatlo1[4]);

glLightf(GL_LIGHT0, GL_SPOT_EXPONENT, swiatlo1[5][0]);

glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, swiatlo1[6][0]);

glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, swiatlo1[7][0]);

glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, swiatlo1[8][0]);

glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, swiatlo1[9][0]);

//ustawienie czarnej kulki symbolizujacej pozycje reflektora

//kulka nie jest oswietlana

glPushAttrib(GL_LIGHTING_BIT);

glPushMatrix();

glDisable(GL_LIGHTING);

glTranslatef(swiatlo1[3][0],swiatlo1[3][1],swiatlo1[3][2]);

glColor3f(0.0,0.0,0.0);

glutSolidSphere(0.4,20,20);

glPopMatrix();

glPopAttrib();

}

else

//wylaczenie zrodla swiatla nr 1

glDisable(GL_LIGHT0);

// Odblokowanie zrodla swiatla nr 2

if (zrodlo2 == 1 ) {

glEnable(GL_LIGHT1);

glLightfv(GL_LIGHT1, GL_AMBIENT, swiatlo2[0]);

glLightfv(GL_LIGHT1, GL_DIFFUSE, swiatlo2[1]);

glLightfv(GL_LIGHT1, GL_SPECULAR, swiatlo2[2]);

glLightfv(GL_LIGHT1, GL_POSITION, swiatlo2[3]);

glLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, swiatlo2[4]);

glLightf(GL_LIGHT1, GL_SPOT_EXPONENT, swiatlo2[5][0]);

glLightf(GL_LIGHT1, GL_SPOT_CUTOFF, swiatlo2[6][0]);

glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, swiatlo2[7][0]);

glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, swiatlo2[8][0]);

glLightf(GL_LIGHT1, GL_QUADRATIC_ATTENUATION, swiatlo2[9][0]);

}

else

//wylaczenie zrodla swiatla nr 2

glDisable(GL_LIGHT1);

}

Funkcją odpowiedzialną za oświetlenie jest glLightfv (GLenum light, GLenum pname,

const GLfloat *params).

Parametr light określa numer źródła światła, którego parametry chcemy zmienić. Numer źródła światła określają omówione juz stałe GL LIGHT. Parametr pname określa parametr źródła światła, który chcemy zmodyfikować.

Dopuszczalne są następujące wartości tego parametru:

— GL_AMBIENT - wartości składowych RGBA światła otaczającego,

— GL_DIFFUSE - wartości składowych RGBA światła rozproszonego,

— GL_SPECULAR - wartości składowych RGBA światła odbitego,

— GL_POSITION - czteroelementowy wektor (x, y, z, w), którego interpretacja zależy od wartości w; jeżeli w ma wartość 1, oznacza to, ze trzy pierwsze współrzędne wektora określają położenie źródła światła; jeżeli natomiast w ma wartość 0, to źródło światła jest światłem kierunkowym, a jego promienie padają w kierunku zdefiniowanym przez trzy pierwsze współrzędne wektora,

— GL_SPOT_DIRECTION - znormalizowany (długości 1) trój współrzędny wektor

określający kierunek reflektora,

— GL_SPOT_EXPONENT - wykładnik tłumienia kątowego reflektora; dopuszczalne

są wartości z przedziału [0, 128],

— GL_SPOT_CUTOFF - kat odcięcia reflektora; dopuszczalne są wartości z przedziału

[0, 90] oraz 180,

— GL_CONSTANT_ATTENUATION - stały współczynnik tłumienia światła,

— GL_LINEAR_ATTENUATION - liniowy współczynnik tłumienia światła,

Najpierw włączamy oświetlenie danego źródła, natomiast potem definiujemy jaki rodzaj światła włączamy dla danego źródła. Podobnie robimy z materiałem podajemy jaki rodzaj materiału ma być włączony. Używamy do tego polecenia:

glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, material1[0]);

Położenie źródła światła nr 1 zależy od pewnych zmiennych, które użytkownik może interaktywnie zmieniać. Z powyższego kodu źródłowego wynika również, że źródło to jest reprezentowane przez kulę, której kolor możemy dowolnie zmieniać ustawiając jej odpowiednie parametry RGB.

Następnie tworzymy sferę o zmiennej parzystej liczbie podziałów poziomych i pionowych. Realizowane jest to przez poniższy kod przy pomocy trybu GL_QUADS_STRIP:

void RysujSfere(double r, int nv, int nh)

{

double dH, dAlfa, dBeta;

int i,j;

dAlfa = 180/(double)nv;

dBeta = 360/(double)nh;

k=0;

for (i=0;i*dAlfa<=180;i++)

{if(k==0)

k=i%2;

else

k=0;

for(j=0;j*dBeta<=360;j++)

{

DefiniujMaterial(k);

glBegin(GL_QUAD_STRIP);

glNormal3f(cos(DEG2RAD(i*dAlfa))*cos(DEG2RAD(j*dBeta)),sin(DEG2RAD(i*dAlfa))*cos(DEG2RAD(j*dBeta)),sin(DEG2RAD(j*dBeta)));

glVertex3f(r*cos(DEG2RAD(i*dAlfa))*cos(DEG2RAD(j*dBeta)),r*sin(DEG2RAD(i*dAlfa))*cos(DEG2RAD(j*dBeta)),r*sin(DEG2RAD(j*dBeta)));

glNormal3f(cos(DEG2RAD(i*dAlfa))*cos(DEG2RAD((j+1)*dBeta)),sin(DEG2RAD(i*dAlfa))*cos(DEG2RAD((j+1)*dBeta)),sin(DEG2RAD((j+1)*dBeta)));

glVertex3f(r*cos(DEG2RAD(i*dAlfa))*cos(DEG2RAD((j+1)*dBeta)),r*sin(DEG2RAD(i*dAlfa))*cos(DEG2RAD((j+1)*dBeta)),r*sin(DEG2RAD((j+1)*dBeta)));

glNormal3f(cos(DEG2RAD((i+1)*dAlfa))*cos(DEG2RAD(j*dBeta)),sin(DEG2RAD((i+1)*dAlfa))*cos(DEG2RAD(j*dBeta)),sin(DEG2RAD(j*dBeta)));

glVertex3f(r*cos(DEG2RAD((i+1)*dAlfa))*cos(DEG2RAD(j*dBeta)),r*sin(DEG2RAD((i+1)*dAlfa))*cos(DEG2RAD(j*dBeta)),r*sin(DEG2RAD(j*dBeta)));

glNormal3f(cos(DEG2RAD((i+1)*dAlfa))*cos(DEG2RAD((j+1)*dBeta)),sin(DEG2RAD((i+1)*dAlfa))*cos(DEG2RAD((j+1)*dBeta)),sin(DEG2RAD((j+1)*dBeta)));

glVertex3f(r*cos(DEG2RAD((i+1)*dAlfa))*cos(DEG2RAD((j+1)*dBeta)),r*sin(DEG2RAD((i+1)*dAlfa))*cos(DEG2RAD((j+1)*dBeta)),r*sin(DEG2RAD((j+1)*dBeta)));

glEnd();

}

}

}

Pionowe pasy na sferze wykonane z różnych materiałów uzyskane zostały dzięki dwóm pętlom for z odpowiednimi warunkami. Zmiana „formatu” pokrycia sfery (na np. sferę w poziome pasy, czy w szachownicę) jest łatwa dzięki modyfikacji właśnie tych warunków w pętlach for.

Jak wspomniałem wcześniej, należało zamodelować sferę z widocznymi podziałami pionowymi zbudowanymi na przemian z innych materiałów. Za interaktywną zmianę liczby podziałów zarówno pionowych jak i poziomych odpowiedzialny jest poniższy kod:

case 'v':

lPionowych = (lPionowych == LPION_MAX)? LPION_MAX : lPionowych + 2;

break;

case 'V':

lPionowych = (lPionowych == LPION_MIN)? LPION_MIN : lPionowych - 2;

break;

case 'h':

lPoziomych = (lPoziomych == LPOZ_MAX)? LPOZ_MAX : lPoziomych + 2;

break;

case 'H':

lPoziomych = (lPoziomych == LPOZ_MIN)? LPOZ_MIN : lPoziomych - 2;

break;

Włączanie/ wyłączanie źródeł światła:

case '1':

zrodlo1 = (zrodlo1 == 1) ? 0 : 1;

break;

case '2':

zrodlo2 = (zrodlo2 == 1) ? 0 : 1;

break;

Zmiana położenia źródła światła numer 1:

case 'w':

katXZ = (katXZ == 355) ? 0 : katXZ + 5;

swiatlo1[3][0] = rswiatla*cos(DEG2RAD(katXZ))*cos(DEG2RAD(katXY));

swiatlo1[3][1] = rswiatla*sin(DEG2RAD(katXZ));

swiatlo1[3][2] = rswiatla*cos(DEG2RAD(katXZ))*sin(DEG2RAD(katXY));

swiatlo1[4][0] = -rswiatla*cos(DEG2RAD(katXZ))*cos(DEG2RAD(katXY));

swiatlo1[4][1] = -rswiatla*sin(DEG2RAD(katXZ));

swiatlo1[4][2] = -rswiatla*cos(DEG2RAD(katXZ))*sin(DEG2RAD(katXY));

break;

case 's':

katXZ = (katXZ == 0) ? 355 : katXZ - 5;

swiatlo1[3][0] = rswiatla*cos(DEG2RAD(katXZ))*cos(DEG2RAD(katXY));

swiatlo1[3][1] = rswiatla*sin(DEG2RAD(katXZ));

swiatlo1[3][2] = rswiatla*cos(DEG2RAD(katXZ))*sin(DEG2RAD(katXY));

swiatlo1[4][0] = -rswiatla*cos(DEG2RAD(katXZ))*cos(DEG2RAD(katXY));

swiatlo1[4][1] = -rswiatla*sin(DEG2RAD(katXZ));

swiatlo1[4][2] = -rswiatla*cos(DEG2RAD(katXZ))*sin(DEG2RAD(katXY));

break;

case 'd':

katXY = (katXY == 0) ? 355 : katXY - 5;

swiatlo1[3][0] = rswiatla*cos(DEG2RAD(katXZ))*cos(DEG2RAD(katXY));

swiatlo1[3][1] = rswiatla*sin(DEG2RAD(katXZ));

swiatlo1[3][2] = rswiatla*cos(DEG2RAD(katXZ))*sin(DEG2RAD(katXY));

swiatlo1[4][0] = -rswiatla*cos(DEG2RAD(katXZ))*cos(DEG2RAD(katXY));

swiatlo1[4][1] = -rswiatla*sin(DEG2RAD(katXZ));

swiatlo1[4][2] = -rswiatla*cos(DEG2RAD(katXZ))*sin(DEG2RAD(katXY));

break;

case 'a':

katXY = (katXY == 355) ? 0 : katXY + 5;

swiatlo1[3][0] = rswiatla*cos(DEG2RAD(katXZ))*cos(DEG2RAD(katXY));

swiatlo1[3][1] = rswiatla*sin(DEG2RAD(katXZ));

swiatlo1[3][2] = rswiatla*cos(DEG2RAD(katXZ))*sin(DEG2RAD(katXY));

swiatlo1[4][0] = -rswiatla*cos(DEG2RAD(katXZ))*cos(DEG2RAD(katXY));

swiatlo1[4][1] = -rswiatla*sin(DEG2RAD(katXZ));

swiatlo1[4][2] = -rswiatla*cos(DEG2RAD(katXZ))*sin(DEG2RAD(katXY));

break;

case 'q':

rswiatla = (rswiatla == 2) ? 2 : rswiatla - 1;

swiatlo1[3][0] = rswiatla*cos(DEG2RAD(katXZ))*cos(DEG2RAD(katXY));

swiatlo1[3][1] = rswiatla*sin(DEG2RAD(katXZ));

swiatlo1[3][2] = rswiatla*cos(DEG2RAD(katXZ))*sin(DEG2RAD(katXY));

swiatlo1[4][0] = -rswiatla*cos(DEG2RAD(katXZ))*cos(DEG2RAD(katXY));

swiatlo1[4][1] = -rswiatla*sin(DEG2RAD(katXZ));

swiatlo1[4][2] = -rswiatla*cos(DEG2RAD(katXZ))*sin(DEG2RAD(katXY));

break;

case 'e':

rswiatla = (rswiatla == 20) ? 20 : rswiatla + 1;

swiatlo1[3][0] = rswiatla*cos(DEG2RAD(katXZ))*cos(DEG2RAD(katXY));

swiatlo1[3][1] = rswiatla*sin(DEG2RAD(katXZ));

swiatlo1[3][2] = rswiatla*cos(DEG2RAD(katXZ))*sin(DEG2RAD(katXY));

swiatlo1[4][0] = -rswiatla*cos(DEG2RAD(katXZ))*cos(DEG2RAD(katXY));

swiatlo1[4][1] = -rswiatla*sin(DEG2RAD(katXZ));

swiatlo1[4][2] = -rswiatla*cos(DEG2RAD(katXZ))*sin(DEG2RAD(katXY));

break;

Obroty sfery:

case '[':

obrot_x=(obrot_x<45.0)?obrot_x+1.0:45.0;

break;

case '{':

obrot_x=(obrot_x>-90.0)?obrot_x-1.0:-90.0;

break;

case ']':

obrot_y=(obrot_y<360.0)?obrot_y+1.0:360.0;

break;

case '}':

obrot_y=(obrot_y>0.0)?obrot_y-1.0:0.0;

break;

Zmiana promienia sfery:

case 'p':

promien = (promien == R_MAX) ? R_MAX : promien + 1;

break;

case 'o':

promien = (promien == 1) ? promien : promien - 1;

break;

Uzyskane wyniki:

Sfera widoczna po włączeniu programu - Sfera po jednoczesnym włączeniu światła

20 podziałów - światła wyłączone reflektorowego i kierunkowego

Sfera po włączeniu zmiennego, Sfera po włączeniu niebieskiego światła

żółtego światła reflektorowego. kierunkowego

Sfera po włączeniu światła reflektorowego i kierunkowego przy zwiększonej liczbie podziałów pionowych i poziomych

Wnioski:

Celem zadań laboratoryjnych było zamodelowanie obiektu składającego się z dwóch różniących się materiałów, oświetlenie sceny dwoma odmiennymi źródłami światła, a następnie zaobserwowaniu relacji łączących te elementy i ich wpływ na otrzymywane efekty wizualne. Napisany program, doskonale ukazuje zasady powstawania barwy, oraz jej związek z właściwościami materiału tworzącego przedmiot, oraz światła na niego padającego. Zatem możemy stwierdzić, że cele zajęć zostały osiągnięte.

Można zauważyć również, że im budowa figury jest dokładniejsza (zbliżona kształtem do rzeczywistej), tym rozchodzące się światło wygląda bardziej naturalnie. Gdybyśmy natomiast pominęli liczenie wektorów normalnych dla każdego fragmentu składowego sfery, oświetlony obiekt wyglądałby bardzo nienaturalnie i sztucznie. Zatem im więcej jest podziałów pionowych i poziomych, tym efekt oświetlenia jest bardziej realistyczny. Jednak przy zbyt dużej liczbie podziałów program działa wyraźnie wolniej.

Tworzenie materiałów, z których składa się obiekt jest bardzo elastyczne. Polega ono na zmianie odpowiednich parametrów w zależności od tego jakie efekty chcemy uzyskać, co nie jest jednak proste w wykonaniu. Jeżeli oświetlamy powierzchnię kilkoma źródłami jednocześnie, nałożenie się ich na siebie powoduje, że powierzchnia ta jest oświetlana światłem o parametrach wypadkowych utworzonych z nakładających się źródeł.

Szczególną uwagę należy również zwracać na poprawne wyznaczanie wektorów normalnych, co jest podstawą do poprawnego działania oświetlenia.

---