sprko-pieci, Studia, WAT Informatyka, s3 - GK - lab grafika komputerowa, Lab3

Temat indywidualnego zadania laboratoryjnego

Wstęp

W trakcie trwania ćwiczenia laboratoryjnego nie udało mi się wykonać wszystkich punków zadania. Brakowało implementacji zmiennego nachylenia orbity względem osi X i Z oraz zmiany promienia orbity kołowej reflektora.

Dodałem kod, który umożliwia taką interakcję. Ponadto dla pełniejszego zobrazowania umieściłem w programie sekwencje instrukcji, która odpowiada za narysowanie aktualnej orbity reflektora. Dodałem także sferę która wskazuje położenie źródła światła nr 1 oraz osie układu współrzędnych.

Modyfikacje zaznaczyłem w algorytmie rozwiązania zadania pionową linią.

Algorytm rozwiązania zadania - rysowanie zadanego obiektu

- kod programu

// Zmienne globalne

double katY = -20.0; // kat okreslajacy polozenie obserwatora względem osi Y

double katRX = 0.0; // kat odchylenia orbity reflektora (swiatlo nr 1) wzgledem osi X

double katRY = 0.0; // kat określający położenie reflektora (swiatlo nr 1) wzgledem osi Y

double katRZ = 0.0; // kat odchylenia orbity reflektora (swiatlo nr 1) wzgledem osi Z

double katX = 20.0; // kat okreslajacy polozenie obserwatora względem osi X

int lPionowych; // liczba pionowych podziałow bryly

int lPoziomych; // liczba piozminych podzialow bryly

double promien; // promien podstawy rysowanej bryly

double wysokosc; // wysokosc rysowanej bryly

int szerokoscOkna = 800;

Int wysokoscOkna = 600;

int lightSwitch[2]={0,0}; // tablica okreslajaca stan źrodla swiatla 0 - wylaczone, 1- wlaczone

float rRef=4; // promien orbity po ktorej porusza sie reflektor

// Tablica parametrow swiatla

GLfloat swiatlo[7][4];

GLfloat swiatlo2[7][4];

// Tablica parametrow materialu z jakiego wykonany jest walec

GLfloat material[4][4];

GLfloat material2[4][4];

void RysujStozek(double h, double r, int nv, int nh)

{

double dH, dAlfa, dR;

int i, j;

int zmienna=1;

dAlfa = 360.0L/(double)nh;

dH = h/(double)nv;

dR = r/nv;

// Pocztaek tworzenia ukladu wspolrzednych

glBegin(GL_LINES);

// Os X

glColor3f(1.0, 0.0, 0.0);

glVertex3f(-20.0, 0.0, 0.0);

glVertex3f(20.0, 0.0, 0.0);

// Os Y

glColor3f(0.0,1.0,0.0);

glVertex3f(0.0, -20.0, 0.0);

glVertex3f(0.0, 20.0, 0.0);

// Os Z

glColor3f(0.0,0.0,1.0);

glVertex3f(0.0, 0.0, -20.0);

glVertex3f(0.0, 0.0, 20.0);

// Koniec tworzenia ukladu wspolrzednych

glEnd();

// Wyznaczenie wierzcholkow i wektorow normalnych dolnej podstawy

glBegin(GL_TRIANGLE_FAN);

glNormal3f(0.0, -1.0, 0.0);

glVertex3f(0.0, 0.0, 0.0);

for (i = 0; i * dAlfa <= 360.0L + dAlfa; i++)

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

glEnd();

// Wyznaczanie wierzcholkow i wektorow normalnych powierzchni bocznych

for (i = 0; floor((i+1)*dH*1.0E10) <= floor(h*1.0E10); i++)

{

for (j = 1; j*dAlfa <= 360.0L + dAlfa; j++)

{

DefiniujMaterial(zmienna);

glBegin(GL_QUADS);

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

glVertex3f( (r-dR)*sin(DEG2RAD((j+1)*dAlfa)),(i+1)*dH, (r-dR)*cos(DEG2RAD((j+1)*dAlfa)));

glNormal3f( sin(DEG2RAD(j*dAlfa)), 0.0, cos(DEG2RAD(j*dAlfa)));

glVertex3f((r-dR)*sin(DEG2RAD(j*dAlfa)), (i+1)*dH, (r-dR)*cos(DEG2RAD(j*dAlfa)));

glNormal3f( sin(DEG2RAD(j*dAlfa)), 0.0, cos(DEG2RAD(j*dAlfa)));

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

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

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

glEnd();

zmienna=!zmienna;

}

r-=dR;

}

void UstawDomyslneWartosciParametrow(void)

{

// Tablica parametrow materialu

GLfloat param_materialu[6][4] = {

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

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

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

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

GLfloat param_materialu2[6][4] = {

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

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

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

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

// Tablica parametrow swiatla

GLfloat param_swiatla[10][4] = {

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

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

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

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

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

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

{10.0, 0.0, 0.0, 0.0}};// [6] kat odciecia swiatla

GLfloat param_swiatla2[10][4] = {

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

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

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

{10.0, 10.0, 10.0, 0.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

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

// Skopiowanie zawartosci tablic param_* do tablic globalnych

memcpy(material, param_materialu, 4*4*sizeof(GLfloat));

memcpy(swiatlo, param_swiatla, 7*4*sizeof(GLfloat));

memcpy(material2, param_materialu2, 4*4*sizeof(GLfloat));

memcpy(swiatlo2, param_swiatla2, 7*4*sizeof(GLfloat));

lPionowych = 8; // Liczba podzialow pionowych

lPoziomych = 4; // Liczba podzialow poziomych

promien = 1.0; // Promien walca

wysokosc = 2.0; // Wysokosc walca

glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);

}

void WlaczOswietlenie(int s1, int s2)

{

// Odblokowanie oswietlenia

glEnable(GL_LIGHTING);

// Odblokowanie zerowego zrodla swiatla

if (s1==1)

{

glEnable(GL_LIGHT0);

katRY=( katRY +5)%360;

swiatlo[3][0]=rRef*cos(DEG2RAD(katRY));

swiatlo[3][1]=wysokosc/2;

swiatlo[3][2]=rRef*sin(DEG2RAD(katRY));

swiatlo[3][3]=1.0;

swiatlo[4][0]=-rRef*cos(DEG2RAD(katRY));

swiatlo[4][1]=-wysokosc/3;

swiatlo[4][2]=-rRef*sin(DEG2RAD(katRY));

swiatlo[4][3]=-1.0;

// Inicjowanie zrodla swiatla

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

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

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

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

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

}

else glDisable(GL_LIGHT0);

if (s2==1)

{

glEnable(GL_LIGHT1);

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

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

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

}

else glDisable(GL_LIGHT1);

}

void DefiniujMaterial(int typ)

{

if(typ==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]);

}

else

{

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]);

}

void WyswietlObraz(void)

{

int j;

glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

UstawParametryWidoku(szerokoscOkna, wysokoscOkna);

WlaczOswietlenie(lightSwitch[0], lightSwitch[1]);

glTranslatef(0, 0, -obsR);

glRotatef(katX, 1, 0, 0);

glRotatef(katY, 0, 1, 0);

glPushMatrix();

glTranslatef(0.0, swiatlo[3][1], 0.0);

glRotatef(katRX, 1,0,0);

glRotatef(katRZ, 0,0,1);

glDisable(GL_LIGHTING);

glBegin(GL_LINES);

glColor3f(0.0,0.0,0.0);

for(j=0; j<=360.0L; j++)

{

glVertex3f(rRef*sin(DEG2RAD(j)), 0.0, rRef*cos(DEG2RAD(j)));

glVertex3f(rRef*sin(DEG2RAD(j+1)), 0.0, rRef*cos(DEG2RAD(j+1)));

}

glEnd();

glTranslatef(swiatlo[3][0], 0.0, swiatlo[3][2]);

glutWireSphere(0.25, 20, 20);

glEnable(GL_LIGHTING);

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

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

glPopMatrix();

Wprowadzona modyfikacja

RysujWalec(wysokosc, promien, lPoziomych, lPionowych);

glutSwapBuffers();

}

opis funkcjonowania algorytmu

Realizacja zadania opiera się o kod i funkcje zamieszczone powyżej.

Pierwsza procedura odpowiedzialna jest na narysowanie w scenie oświetlanego obiektu - stożek oraz osi układu współrzędnych, w odniesieniu do których łatwo ocenić aktualne położenie elementów sceny.

Funkcja przyjmuje jako parametry kolejno

void RysujStozek(double h, double r, int nv, int nh)

i interpretuje w następujący sposób

1. wysokość bryły

2. promień podstawy

3. liczba podziałów pionowych

4. liczba podziałów poziomych

Wstępnie procedura rysuje układ współrzędnych

glBegin(GL_LINES);

// Os X

glColor3f(0.0, 0.0, 0.0);

glVertex3f(-20.0, 0.0, 0.0);

glVertex3f(20.0, 0.0, 0.0);

// Os Y

glColor3f(0.0,0.0,0.0);

glVertex3f(0.0, -20.0, 0.0);

glVertex3f(0.0, 20.0, 0.0);

// Os Z

glColor3f(0.0,0.0,0.0);

glVertex3f(0.0, 0.0, -20.0);

glVertex3f(0.0, 0.0, 20.0);

// Koniec tworzenia ukladu wspolrzednych

glEnd();

z wykorzystaniem trybu graficznego opartego na liniach. Łączy dwa punkty umieszczone na odpowiedniej osi. Następnie, w oparciu o techniki poznane na pierwszych ćwiczeniach laboratoryjnych, w trybie graficznym GL_QUADS wykreślam stożek