Partea a ii-a : Implementarea de aplicaţii Opengl folosind biblioteca glut

II.7.3. Dreptunghiuri în planul XOY

OpenGL furnizează o funcţie particulară, care permite desenarea unui dreptunghi cu interiorul plin, în planul XOY:

void glRect{sifd}(TYPE x1, TYPE y1, TYPE x2, TYPE y2);
void glRect{sifd}v(TYPE* v1, TYPE* v2);

Funcţia afişează dreptunghiul definit de colţurile (x1, y1) şi (x2, y2). Dreptunghiul se află în planul z=0 şi are laturile paralele cu axele x, respectiv y. Dacă este folosită varianta cu vectori, colţurile dreptunghiului sunt specificate prin doi vectori, fiecare conţinând o pereche (x, y). TYPE reprezintă tipul coordonatelor colţurilor dreptunghiului (s - GLshort, i – GLint , f - GLfloat, d - GLdouble).

II.8. Specificarea atributelor de afişare ale primitivelor geometrice

În mod implicit un punct este desenat ca un singur pixel ecran, un segment de dreapta este desenat ca o linie continuă de lăţime egală cu un pixel, iar poligoanele sunt afişate având conturul cu linie continuă şi interior gol.

II.8.1. Dimensiunea punctelor

Pentru a specifica dimensiunea unui punct afişat se foloseşte funcţia glPointSize.

void glPointSize(GLfloat size);

Funcţia setează lăţimea în pixeli a punctelor ce vor fi afişate. Parametrul size reprezintă dimensiunea punctului exprimată în pixeli ecran. Ea trebuie să fie mai mare ca 0.0, iar valoarea sa implicită este 1.0.

II.8.2. Atributele liniilor

În OpenGL segmentele de dreaptă pot fi desenate având diferite lăţimi, ca linii continue sau ca linii punctate sau întrerupte.

II.8.2.1.Lăţimea liniilor

void glLineWidth(GLfloat width);

Funcţia setează lăţimea în pixeli a liniilor ce vor fi afişate; width trebuie să fie mai mare ca 0.0, iar valoarea implicită este 1.0.

II.8.2.2. Tipul liniilor 

Pentru afişarea liniilor punctate sau întrerupte se va apela funcţia glLineStipple, care defineşte şablonul de generare a liniilor, apoi se va activa folosirea liniilor punctate sau întrerupte folosind funcţia glEnable:

void glLineStipple(GLint factor, GLushort pattern);

Funcţia setează şablonul curent de generare a liniilor.

• 
  factor - este un multiplicator pentru fiecare bit din şablonul de generare a liniei cu şablon. De exemplu, dacă factor = 3 atunci fiecare bit din şablon va fi folosit de trei ori înainte ca următorul bit din şablon să fie folosit. Are valori în intervalul [1, 255]
  
• 
  pattern - reprezintă o succesiune de 16 biţi care va fi repetată pentru a genera o linie cu şablon. Dacă bit = 1 se face afişarea, dacă bit = 0 nu se afişează; ordinea de parcurgerea a biţilor în şablon este de la bitul cel mai puţin semnificativ către bitul cel mai semnificativ. Şablonul poate fi multiplicat prin folosirea parametrului factor, care multiplică fiecare succesiune de biţi cu valori egale (1 sau 0) din şablon cu valoarea factor. Astfel, dacă în sablon apar 3 biţi consecutivi cu valoarea 1 şi factor = 2, se vor genera 6 biţi cu valoarea 1.
  

In figura II.5 sunt exemplificate diferite tipuri de linii obţinute prin alegerea valorilor pattern şi factor.

Figura II.5

Generarea de linii cu şablon se va activa apelând funcţia glEnable cu parametrul GL_LINE_STIPPLE şi va fi dezactivată prin apelul funcţiei glDisable cu acelaşi argument.

void glEnable(Glenum cap);

void glDisable(GLenum cap);

cap este o constantă simbolică ce specifică o ‘capabilitate’ OpenGL. Ea poate avea una din următoarele valori:

• 
  GL_CULL_FACE - activează / dezactivează eliminarea părţilor nevizibile ale obiectelor folosind metoda Back Face Culling.
  
• 
  GL_DEPTH_TEST –activează / dezactivează calcularea valorilor buffer-ului de adâncime.
  
• 
  GL_LIGHTi - activează / dezactivează luarea în calcul a sursei de lumină şi la calculul de iluminare.
  
• 
  GL_LIGHTING – activează / dezactivează calcularea culorii corespunzătoare fiecărui vârf.
  
• 
  GL_LINE_STIPPLE – activează / dezactivează generarea liniilor folosind şablon.
  
• 
  GL_NORMALIZE - acitivează /dezactivează normalizarea vectorilor normală.
  
• 
  GL_POLYGON_STIPPLE - activează / dezactivează folosirea şablonului curent la afişarea poligoanelor.
  

Exemplu:

glLineStipple(1, 0x3F07);

glEnable(GL_LINE_STIPPLE);
În acest exemplu, pentru şablonul 0x3F07 (0011111100000111), o linie va fi desenată cu 3 pixeli vizibili, apoi 5 invizibili, 6 vizibili şi 2 invizibili (ordinea de parcurgere este de la bitul cel mai puţin semnificativ către cel mai semnificativ). Dacă factor = 2, şablonul va fi multiplicat: 6 pixeli vizibili, 10 invizibili, 12 vizibili şi 4 invizibili. Figura următoare exemplifică linii desenate folosind diverse şabloane şi diferiţi factori de multiplicare. Dacă nu se activează generarea liniilor cu şablon, afişarea va decurge ca şi cum pattern ar fi 0xFFFF şi factor 1. Generarea liniilor cu şablon poate fi combinată cu setarea diferitelor lăţimi de linie pentru a produce linii punctate de diferite lăţimi.
O modalitate de a privi generarea liniilor cu şablon este aceea că şablonul este deplasat cu o poziţie de fiecare dată când este afişat un pixel (sau factor pixeli sunt afişati, dacă factor este diferit de 1). Dacă sunt desenate o serie de segmente de dreaptă conectate între apelurile funcţiilor glBegin şi glEnd, atunci şablonul va continua să fie deplasat când se trece de la un segment la altul. În acest mod un şablon este folosit pentru mai multe segmente de dreaptă conectate între ele. La execuţia funcţiei glEnd şablonul va fi resetat şi dacă în continuare, înainte de a dezactiva generarea de segmente de dreaptă cu şablon, mai sunt afişate segmente de dreaptă, atunci la generare se va folosi şablonul de la început. Dacă segmentele de dreaptă sunt afişate folosind GL_LINES, atunci şablonul va fi resetat pentru fiecare segment de dreaptă.
Programul « exemplul3 » prezentat în continuare exemplifică folosirea diferitelor

şabloane şi a diferitelor lăţimi pentru generarea liniilor.

/* exemplul3.c*/
#include "glut.h"
#define drawOneLine(x1,y1,x2,y2) glBegin(GL_LINES); \

glVertex2f ((x1),(y1)); glVertex2f ((x2),(y2)); glEnd();

void myinit (void)

{ /* fondul are culoarea neagră */

glClearColor (0.0, 0.0, 0.0, 0.0);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

glOrtho(50.0, 150.0, -50.0, 350.0, -1.0, 1.0);

}
void display(void)

{

int i;

glClear (GL_COLOR_BUFFER_BIT);

/* afişează toate liniile cu alb */

glColor3f (1.0, 1.0, 1.0);
/* prima linie: 3 linii, fiecare cu un şablon */

glEnable (GL_LINE_STIPPLE);

glLineStipple (1, 0x0101); /* linie punctată */

drawOneLine (50.0, 125.0, 150.0, 125.0);

glLineStipple (1, 0x00FF); /* linie întreruptă */

drawOneLine (150.0, 125.0, 250.0, 125.0);

glLineStipple (1, 0x1C47); /* întreruptă/punctată/întreruptă */

drawOneLine (250.0, 125.0, 350.0, 125.0);

/* linia a doua */

glLineWidth (5.0);

glLineStipple (1, 0x0101);

drawOneLine (50.0, 100.0, 150.0, 100.0);

glLineStipple (1, 0x00FF);

drawOneLine (150.0, 100.0, 250.0, 100.0);

glLineStipple (1, 0x1C47);

drawOneLine (250.0, 100.0, 350.0, 100.0);

glLineWidth (1.0);
/* linia a treia: 6 linii cu şablon întrerupt/punctat/întrerupt, */

/* ca parte a unei singure linii */

glLineStipple (1, 0x1C47);

glBegin (GL_LINE_STRIP);

for (i = 0; i < 7; i++)

glVertex2f (50.0 + ((GLfloat) i * 50.0), 75.0);

glEnd ();
/* linia a patra: 6 linii independente cu şablon */

/* întrerupt/punctat/întrerupt */

for (i = 0; i < 6; i++) {

drawOneLine (50.0 + ((GLfloat) i * 50.0),

50.0, 50.0 + ((GLfloat)(i+1) * 50.0), 50.0);

}
/* linia a cincea: 1 linie cu şablon întrerupt/punctat/întrerupt */

/* şi factor de multiplicare egal cu 5 */

glLineStipple (5, 0x1C47);

drawOneLine (50.0, 25.0, 350.0, 25.0);

glFlush ();

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

{

glutInit(&argc, argv);

glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);

glutInitWindowSize (250, 250);

glutInitWindowPosition (100, 100);

glutCreateWindow (argv[0]);

myinit ();

glutDisplayFunc(display);

glutMainLoop();

return 0;

}