OpenGL Color în grafica bidimensională

OpenGL are o colecție mare de funcții care pot fi utilizate pentru a specifica culori pentru geometria pe care o desenăm. Aceste funcții au nume de forma glColor*, unde „*” reprezintă un sufix care indică numărul și tipul parametrilor. Ar trebui să vă avertizez acum că pentru grafica 3D realistă, OpenGL are o noțiune mai complicată de culoare care utilizează un set diferit de funcții. Veți afla despre asta în capitolul următor, dar deocamdată ne vom limita la glColor*.

De exemplu, funcția glColor3f are trei parametri de tip float. Parametrii indică componentele roșie, verde și albastră ale culorii sub formă de numere în intervalul 0,0 – 1,0. (De fapt, valorile din afara acestui interval sunt permise, chiar și valorile negative. Când valorile culorilor sunt utilizate în calcule, valorile din afara intervalului vor fi utilizate ca date. Când o culoare apare efectiv pe ecran, valorile componentelor sale sunt fixate în intervalul de la 0 la 1. Adică, valorile mai mici decât zero sunt schimbate în zero, iar valorile mai mari decât unu sunt schimbate în unu.)

Puteți adăuga o a patra componentă culorii utilizând glColor4f(). A patra componentă, cunoscută sub numele de alfa, nu este utilizată în modul implicit de desen, dar este posibil să configurați OpenGL să o utilizeze ca grad de transparență al culorii, similar cu utilizarea componentei alfa în API-urile grafice 2D pe care le-am analizat. Aveți nevoie de două comenzi pentru a activa transparența:

glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

Prima comandă permite utilizarea componentei alfa. Aceasta poate fi dezactivată apelând glDisable(GL_BLEND). Când opțiunea GL_BLEND este dezactivată, componenta alfa este pur și simplu ignorată. A doua comandă indică modul în care va fi utilizată componenta alfa a unei culori. Parametrii arătați aici sunt cei mai comuni; aceștia implementează transparența în mod obișnuit. Trebuie să menționez că, deși transparența funcționează bine în 2D, este mult mai dificil să o utilizați corect în 3D.

Dacă doriți să utilizați valori întregi de culoare în intervalul 0 – 255, puteți utiliza glColor3ub() sau glColor4ub pentru a seta culoarea. În aceste nume de funcții, „ub” înseamnă „unsigned byte”. Unsigned byte este un tip de date pe opt biți cu valori în intervalul 0 – 255. Iată câteva exemple de comenzi pentru setarea culorilor de desen în OpenGL:

glColor3f(0,0,0);          // Desenează în negru.
glColor3f(1,1,1);          // Desenează în alb.
glColor3f(1,0,0);          // Desenează în roșu de intensitate maximă.
glColor3ub(1,0,0);         // Desenează într-o culoare puțin diferită de
                           // negru.  (Sufixul „ub” sau „f” este important!)
glColor3ub(255,0,0);       // Desenează în roșu intens.
glColor4f(1, 0, 0, 0.5);   // Desenează în roșu transparent, dar numai dacă
                           // OpenGL a fost configurat să facă transparență.
                           // În mod implicit, aceasta este aceeași cu desenarea în roșu simplu.

 

Utilizarea oricăreia dintre aceste funcții setează valoarea unei „culori curente”, care face parte din starea OpenGL. Când generați un vârf cu una dintre funcțiile glVertex*, culoarea curentă este salvată împreună cu coordonatele vârfului, ca atribut al vârfului. Vom vedea că vârfurile pot avea și alte tipuri de atribute, precum și culoare. Un punct interesant despre OpenGL este că culorile sunt asociate cu vârfuri individuale, nu cu forme complete. Prin schimbarea culorii curente între apelurile către glBegin() și glEnd(), puteți obține o formă în care diferite vârfuri au atribute de culoare diferite. Când faceți acest lucru, OpenGL va calcula culorile pixelilor din interiorul formei prin interpolarea culorilor vârfurilor. (Din nou, deoarece OpenGL este extrem de configurabil, trebuie să menționez că interpolarea culorilor este doar comportamentul implicit.)

De exemplu, iată un triunghi în care celor trei vârfuri le sunt atribuite culorile roșu, verde și albastru:

Această imagine este adesea folosită ca un fel de exemplu „Hello World” pentru OpenGL. Triunghiul poate fi desenat cu comenzile

glBegin(GL_TRIANGLES);
glColor3f( 1, 0, 0 ); // red
glVertex2f( -0.8, -0.8 );
glColor3f( 0, 1, 0 ); // green
glVertex2f( 0.8, -0.8 );
glColor3f( 0, 0, 1 ); // blue
glVertex2f( 0, 0.9 );
glEnd();

Rețineți că atunci când desenați o primitivă, nu este nevoie să setați explicit o culoare pentru fiecare vârf, așa cum s-a procedat aici. Dacă doriți o formă care să fie într-o singură culoare, trebuie doar să setați culoarea curentă o singură dată, înainte de a desena forma (sau imediat după apelul la glBegin(). De exemplu, putem desena un triunghi galben solid cu

glColor3ub(255,255,0); // yellow
glBegin(GL_TRIANGLES);
glVertex2f( -0.5, -0.5 );
glVertex2f( 0.5, -0.5 );
glVertex2f( 0, 0.5 );
glEnd();

De asemenea, rețineți că culoarea pentru un vârf este specificată înainte de apelul la glVertex* care generează vârful.

Versiunea online a acestei secțiuni are o demonstrație interactivă care desenează triunghiul OpenGL de bază, cu vârfuri de diferite culori. Această demonstrație este primul nostru exemplu OpenGL. Demonstrația folosește de fapt WebGL, așa că o puteți folosi ca test pentru a verifica dacă browserul dvs. web acceptă WebGL.

Demonstrație

http://math.hws.edu/eck/cs424/graphicsbook2018/demos/c3/first-triangle-demo.html

Programul exemplu jogl/FirstTriangle.java desenează triunghiul OpenGL de bază folosind Java. Programul glut/first-triangle.c face același lucru folosind limbajul de programare C. Iar glsim/first-triangle.html este o versiune care folosește simulatorul JavaScript, care implementează doar părțile OpenGL 1.1 care sunt acoperite în această carte. Oricare dintre aceste programe ar putea fi folosit pentru a experimenta desenul 2D în OpenGL. Și le puteți folosi pentru a testa mediul de programare OpenGL.

O operațiune comună este de a goli zona de desen prin umplerea ei cu o culoare de fundal. Este posibil să faceți acest lucru desenând un dreptunghi mare colorat, dar OpenGL are o modalitate potențial mai eficientă de a face acest lucru. Funcția

glClearColor(r,g,b,a);

configurează o culoare care va fi utilizată pentru golirea zonei de desen. (Aceasta setează doar culoarea; culoarea nu este utilizată până când nu dați comanda de golire a zonei de desen.) Parametrii sunt valori cu virgulă mobilă în intervalul 0 la 1. Nu există variante ale acestei funcții; trebuie să furnizați toate cele patru componente de culoare, iar acestea trebuie să fie în intervalul 0 la 1. Culoarea implicită de golire este toate zerouri, adică negru cu o componentă alfa egală cu zero. Comanda pentru efectuarea golirii efective este:

glClear( GL_COLOR_BUFFER_BIT );

Termenul corect pentru ceea ce am numit zona de desen este bufferul de culoare, unde „buffer” este un termen general care se referă la o regiune din memorie. OpenGL folosește mai multe buffere pe lângă bufferul de culoare. Vom întâlni „bufferul de adâncime” în câteva clipe. Comanda glClear poate fi utilizată pentru a goli mai multe buffere diferite în același timp, ceea ce poate fi mai eficient decât golirea lor separat, deoarece golirea se poate face în paralel. Parametrul glClear îi spune ce buffer sau buffere să șteargă. Pentru a șterge mai multe buffere simultan, combinați constantele care le reprezintă cu o operație aritmetică SAU. De exemplu,

glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

Aceasta este forma de glClear utilizată în general în grafica 3D, unde bufferul de adâncime joacă un rol esențial. Pentru grafica 2D, bufferul de adâncime nu este în general utilizat, iar parametrul corespunzător pentru glClear este pur și simplu GL_COLOR_BUFFER_BIT.

Sursa: David J. Eck, Introduction to Computer Graphics (Eck), LibreTexts, licența CC BY-NC-SA 4.0. Traducere și adaptare Nicolae Sfetcu