Ministerul Educaţiei, Culturii și Cercetării al Republicii Moldova

Universitatea Tehnică a Moldovei

Departamentul Ingineria Software și Automatică

RAPORT
Lucrare de laborator Nr.1
Disciplina: Programarea Pilotată de Evenimente

Tema:  Primitive grafice simple

A efectuat gr.TI-182

A verificat lect.univ:
 Rotaru Lilia
 Ursu Adriana

Chișinău 2020
Definirea ¸si afi¸sarea obiectelor grafice

Parametrii ini¸tiali
Afi¸sarea unor obiecte geometrice sau primitive grafice se face prin parcurgerea
obliga- torie a unor etape prestabilite, precum managementul ferestrei grafice, definirea
culorilor fundalului ¸si a obiectului, a formei acestuia ¸si executarea instruc¸tiunilor
grafice pentru transferul imaginii rezultate ˆın bufferul grafic.

S¸tergerea ferestrei grafice. Afi¸sarea pe un monitor se face diferit fa¸ta˘

de cazul unei coli de hˆartie. Diferen¸ta este realizat˘a prin faptul c˘a hˆartia este
deja alb˘a sau avˆand o anumit˘a culoare prestabilit˘a, ˆın timp ce ˆın cazul
monitorului culoarea de fundal trebuie specificat˘a, iar eventualele artefacte deja
existente trebuie eliminate prin ¸stergerea buffe- rului. Toate opera¸tiile sunt efectuate
ˆın cadrul func¸tiei de ini¸tializare init().

Pentru setarea culorii fundalului se utilizeaz˘a instruc¸tiunea glClearColor() ai

c˘arei parametri sunt cele trei culori primare (RGB) ¸si parametrul de transparen¸t˘a
alpha (A). S¸tergerea con¸tinutului de memorie asociat bufferului video se poate face
cu ajutorul instruc¸tiunii glClear() cu parametrul specific tipului bufferului ¸sters de
con¸tinut. De exemplu, liniile de cod urm˘atoare permit setarea culorii de fundal a
ferestrei ˆın negru ¸si
¸stergerea bufferului video de culoare.

void init (void){

glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
}

Parametrii posibili ai instructiunii glClear() sunt enumera¸ti ˆın tabelul urm˘ator

 Pentru a putea ¸sterge mai multe buffere, instruc¸tiunea glClear() se poate utiliza
repe-titiv prin modificarea parametrului
glClear(GL_COLOR_BUFFER_BI
T);
glClear(GL_DEPTH_BUFFER_BIT
);
glClear(GL_ACCUM_BUFFER_BI
T);
sau o singur˘a dat˘a, prin enumerarea parametrilor.
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|
GL_ACCUM_BUFFER_BIT);
ˆIn ultimul caz durata necesar˘a efectu˘arii opera¸tiilor de ¸stergere este poten¸tial
mai mic˘a decˆat ˆın situa¸tia enumer˘arii succesive.

Alegerea unei culori. Trasarea unui obiect grafic se efectueaz˘a ˆın OpenGL
independent de alegerea culorii asociate obiectului. Odat˘a aleas˘a o anumit˘a
culoare, toate obiectele care vor fi trasate ulterior vor avea culoarea respectiv˘a, astfel
ˆıncˆat dac˘a se dore¸ste afi¸sarea unor obiecte ˆın culori diferite, de fiecare dat˘a este
necesar˘a modificarea culorii curente.

Alegerea unei culori curente se face ˆın cadrul func¸tiei display() cu ajutorul
instruc¸tiu- nii glColor(). ˆIn func¸tie de tipul argumentelor introduse, func¸tia cap˘at˘a
un sufix specific (ˆın cazul parametrilor de tip real, func¸tia devine glColor3f()).
Exemplul de mai jos permite alegerea unei culori curente ro¸sii.
void display (void){ glColor3f(1.0,
0.0, 0.0);
...
}
Parametrii de culoare specifici celor trei culori primare (RGB) iau valori reale
cuprinse ˆıntre 0 (lips˘a) ¸si 1 (maxim). Astfel, cele opt culori elementare pot fi
definite cu ajutorul urm˘atoarelor opt variante de instruc¸tiuni.
glColor3f(0.0, 0.0, 0.0); negru
glColor3f(1.0, 0.0, 0.0); rosu
glColor3f(0.0, 1.0, 0.0); verde
glColor3f(0.0, 0.0, 1.0); albastru
glColor3f(0.0, 1.0, 1.0); cyan
glColor3f(1.0, 0.0, 1.0); magenta
glColor3f(1.0, 1.0, 0.0); galben
glColor3f(1.0, 1.0, 1.0); alb
De remarcat faptul c˘a ˆın cazul instruc¸tiunii de ¸stergere a bufferului existau patru
para- metrii, ˆın timp ce ˆın cazul instruc¸tiunii de alegere a culorii curente num˘arul
parametri-lor este doar de trei, lipsind transparen¸ta (alpha).

Execu¸tia instruc¸tiunilor grafice. Datorit˘a multitudinii de variante ale

dispozitivelor grafice hardware datorate specializ˘arii fiec˘aruia din acestea, opera¸tiile
pot fi efectuate ˆın ordine diferit˘a de c˘atre procesorul grafic. Pentru a asigura
execu¸tia instruc¸tiunilor din cadrul unei aplica¸tii, ˆın cadrul func¸tiei display() se
apeleaz˘a instruc¸tiunile glFlush()
¸si glFinish().
 22

void display (void){

...
glFlush();
glFinish();
}

Prima dintre ele asigur˘a ˆınceperea execu¸tiei instruc¸tiunilor precedente acesteia, ˆın
timp ce a doua for¸teaz˘a execu¸tia tuturor instruc¸tiunilor anterioare. Doar ˆın cazul
ˆın care, pen- tru o aplica¸tie dat˘a, simpla utilizare a lui glFlush() nu este
suficient˘a, se recomand˘a includerea lui glFinish().

Instruc¸tiunea glFlush() se utilizeaz˘a doar ˆın cazul alegerii ˆın cadrul func¸tiei principale
main() a unor buffere simple.

int main (int argc, char** argv){

...
glutInitDisplayMode(GLUT_SINGLE);
...
}
ˆIn situa¸tia ˆın care se utilizeaz˘a buffere duble (mai ales ˆın cazul anima¸tiilor),
ˆın locul lui glFlush() se folose¸ste instruc¸tiunea glutSwapBuffers().

int main (int argc, char** argv){

...
glutInitDisplayMode(GLUT_DOUBLE);
...
}

Dubla bufferare permite o execu¸tie mai rapid˘a a instruc¸tiunilor grafice

deoarece, ˆın timpul afi¸s˘arii unui buffer curent, cel˘alalt buffer este utilizat pentru
realizarea ˆın paralel a cadrului urm˘ator al secven¸tei de imagini. Succesiunea de cadre
se realizeaz˘a prin schim- barea alternativ˘a a bufferelor curente afi¸sate.

Sistemul de coordonate al ferestrei. Alegerea dimensiunilor ¸si pozi¸tiei

ferestrei gra- fice curente se face ˆın cadrul func¸tiei principale main(), prin
intermediul procedurilor
glutInitWindowPosition() ¸si glutInitWindowSize(). Punctul de referin¸ta˘ pentru
pozi¸tionarea ferestrei este reprezentat de col¸tul din stˆanga jos ale c˘arui coordonate ˆın
pixeli este (0, 0). Dimensiunile ferestrei reprezint˘a num˘arul de pixeli de pe ecranul
moni- torului pe axa orizontal˘a (l˘a¸timea) ¸si, respectiv, pe axa vertical˘a
(ˆın˘al¸timea).

ˆIn interiorul ferestrei, ini¸tial sistemul de coordonate de vizualizare este centrat ˆın
punc- tul de coordonate (0, 0, 0) ¸si ia valori pe axele orizontale ¸si verticale cuprinse
ˆıntre -1 ¸si 1. De remarcat faptul c˘a axa corespunz˘atoare adˆancimii nu este vizibil˘a.
ˆIn acest moment singurele obiecte care pot fi vizualizate sunt obiectele din plan (2D).

ˆIn cazul modific˘arii dimensiunii sau pozi¸tiei ferestrei se utilizeaz˘a un set de

instruc¸tiuni situate ˆın interiorul func¸tiei reshape(), instruc¸tiuni care vor fi
prezentate ˆın capitolul dedicat proiec¸tiilor ¸si transform˘arilor (§5).
Puncte, linii ¸si poligoane
Cele mai simple primitive geometrice sunt reprezentate de c˘atre puncte, linii ¸si poligoa- ne.
Acestea pot fi trasate fie ˆın plan (2D), fie ˆın spa¸tiu (3D), ˆın func¸tie de coordonatele definite.

Punctele reprezint˘a numere reale, denumite ¸si vertex-uri, definite fie ˆın plan, prin spe-
cificarea coordonatelor x ¸si y, fie ˆın spa¸tiu, prin specificarea celor trei coordonate x, y ¸si
z. ˆIn cazul coordonatelor omogene poate exista o a patra coordonat˘a, notat˘a w. Dac˘a w
este nenul, coordonatele punctului ˆın spa¸tiul tridimensional sunt (x/w, y/w, z/w).

ˆIn OpenGL un punct (sau vertex) este specificat cu ajutorul instruc¸tiunii glVertex(). ˆIn
func¸tie de num˘arul de coordonate ¸si de tipul de date, func¸tia cap˘at˘a sufixe, dup˘a cum
urmeaz˘a.
glVertex[234][sifd][v](x,y,[z],[w]);
Sufixul [234] reprezint˘a num˘arul de coordonate utilizate pentru definirea punctului, iar
[sifd] define¸ste tipul datelor utilizate. ˆIn cazul ˆın care se utilizeaz˘a vectori de coordo- nate
predefini¸ti, apare ¸si sufixul [v]. ˆIn exemplele urm˘atoare se prezint˘a diferite moduri
de definire a unor puncte.
glVertex2s(2, 1);

glVertex3d(0.2, 1.2, 3.1415926535898);

glVertex4f(2.3, 1.1, -3.0, 2.0);

GLdouble dvect[3] = (5.2, 9.2, 24.0); glVertex3dv(dvect);
Liniile (sau segmentele de dreapt˘a) sunt specificate ˆın OpenGL prin intermediul puncte- lor de
ˆınceput ¸si sfˆar¸sit ale acestora, avˆand dimensiune finit˘a. Poligoanele sunt definite ca
regiuni ˆınchise, avˆand o singur˘a bucl˘a format˘a din segmente de dreapt˘a, definite prin
intermediul unor puncte.

Specificarea coordonatelor unor puncte cu ajutorul instruc¸tiunii glVertex() serve¸ste la

definirea diferitelor obiecte grafice, ˆın cadrul unei structuri, avˆand forma urm˘atoare.
glBegin(...);
glVertex(...);
...
glVertex(...); glEnd();
Instruc¸tiunea glBegin() are ca argument tipul de obiect grafic ales, variantele posibile fiind
specificate ˆın tabelul de mai jos. Numa˘rul de puncte incluse ˆın interiorul structurii este dat de
tipul de obiect grafic ales. De exemplu, pentru definirea unui triunghi sunt necesare trei puncte,
iar pentru definirea unui poligon, num˘arul acestora poate fi de minim trei. ˆIn tabelul urm˘ator se
prezint˘a tipurile de primitive grafice definite cu ajutorul unei structuri glBegin().
 void display (void){
...
glColor3f(1.0, 0.0, 0.0); // culoare rosie
glBegin(GL_LINES); // segment de dreapta
glVertex3f(2.0, 3.0, 1.0); // punct de inceput glVertex3f(1.0,
1.0, 3.0); // punct de sfarsit
glEnd();
...
}
De asemenea, fiecare nod din cadrul unei primitive grafice poate avea propria culoare, caz ˆın care
instruc¸tiunea glColor() se repret˘a ˆın interiorul structurii glBegin() pentru fiecare modificare de culoare
ˆın parte.

void display (void){

...
glBegin(GL_TRIANGLES); // triunghi glColor3f (1.0,
0.0, 0.0); // culoare rosie
glVertex3f (0.2, 0.25, 0.0); // varful 1
glColor3f (0.0, 1.0, 0.0); // culoare verde
glVertex3f (0.8, 0.25, 0.0); // varful 2
glColor3f (0.0, 0.0, 1.0); // culoare albastra
glVertex3f (0.5, 0.8, 0.0); // varful 3 glEnd();
...
}

COD SURSA: (Microsoft Visual Studio)

#include <GL/glut.h>

void init(void) {
glClearColor(0.0, 0.0, 0.0, 0.0);
}

void display(void) {
glClear(GL_COLOR_BUFFER_BIT);
glPolygonMode(GL_FRONT, GL_FILL); // fateta exterioara umpluta glPolygonMode(GL_BACK, GL_LINE);
// fateta interioara goala glFrontFace(GL_CW); // sens orar = fateta interioara
glBegin(GL_POLYGON); // poligonul 1, sens orar
glVertex3f(0.8, -0.8, 0.0);
glVertex3f(0.2, -0.8, 0.0);
glVertex3f(0.2, -0.2, 0.0);
glVertex3f(0.8, -0.2, 0.0);
glEnd();
glBegin(GL_POLYGON); // poligonul 2, sens invers orar glVertex3f(0.2, 0.2, 0.0);
glVertex3f(0.8, 0.2, 0.0);
glVertex3f(0.8, 0.8, 0.0);
glVertex3f(0.2, 0.8, 0.0); glEnd();
glFrontFace(GL_CCW); // sens orar = fateta exterioara
glBegin(GL_POLYGON); // poligonul 3, sens orar glVertex3f(-0.2, -0.8, 0.0);
glVertex3f(-0.8, -0.8, 0.0);
glVertex3f(-0.8, -0.2, 0.0);
glVertex3f(-0.2, -0.2, 0.0); glEnd();
 glBegin(GL_POLYGON); // poligonul 4, sens invers orar glVertex3f(-0.2, 0.8, 0.0);
glVertex3f(-0.8, 0.8, 0.0);
glVertex3f(-0.8, 0.2, 0.0);
glVertex3f(-0.2, 0.2, 0.0); glEnd();
glFlush();
}

int main(int argc, char** argv) {

glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); glutInitWindowSize(250, 250);
glutInitWindowPosition(100, 100); glutCreateWindow("FIGURI");
init();
glutDisplayFunc(display);
glutMainLoop();
return 0;
}

Rezultatul:

Concluzie:
În acest laborator s-a creat o aplicație Windows în care sunt desenate 2 triunghiuri și 2 pătrate. În laboratorul dat sa
folosit OpenGL (Open Graphics Library) care reprezint˘a o specifica¸tie standardizat˘a a unei interfe-te de
programare a aplica¸tiilor (API) portabil˘a pe diferite platforme, destinat˘a cre˘arii aplica¸tiilor de grafic˘a
computerizat˘a 2D ¸si 3D.

Bibliografie:

Grafică computerizată : Aplicaţii în OpenGL / Cristian Molder. -

Bucureşti : Editura Academiei Tehnice Militare, 2016