Ministerul Educației al Republicii Moldova

Universitatea de Stat din Moldova

Facultatea de Matematică și Informatică

Lucrare de laborator nr.3

La disciplina Grafica Rastru
Tema:"Bibliotecile OpenGL."

Efectuat de studentul
grupei IA21: Ghiderman Ion

Verificat de lectorul universitar:

Marin Ghenadie

Chişinău, 2015
1
 Condiția laboratorului:

De desenat forma conică a următorului desen în MS Visio, utilizînd bibliotecile

grafice OpenGL.

Note teoretice:

OpenGL (Open Graphics Library) este o specificație standard care

definește un API cross-platform (application programming interface) foarte utilizat
pentru programarea componentelor grafice 2D si 3D ale programelor de calculator.
Interfața constă in peste 250 de apeluri diferite care pot fi folosite pentru a desena
scene 3D complexe din primitive simple. OpenGL a fost dezvoltat de Silicon
Graphics Inc. (SGI) in 1992 și este foarte utilizat în grafică asistată de calculator,
realitate virtuală, visualizare științifică, simulări de zboruri sau jocuri pe calculator.
Acest ultim domeniu este in strânsă competiție cu tehnologia DirectX de
la Microsoft (vezi OpenGL vs. Direct3D). OpenGL este condus de un consortiu
tehnologic non-profit, Khronos Grup.

2
OpenGL servește două scopuri principale:

 Pentru a ascunde complexitatea interfațării cu diferite acceleratoare 3D, prin

prezentarea programatorului cu un singur API uniform.
 Pentru a ascunde capabilități diferitelor platforme hardware, prin solicitarea
ca toate implementarile să accepte caracteristica OpenGL ca un set complet (cu
ajutorul software-ul emulation, dacă este necesar).
Funcționarea OpenGL de bază este de a accepta primitive, cum ar fi puncte,
linii și poligoane, și de a le converti în pixeli. Acest lucru se face printr-o conducta
grafică - (graphics pipeline), cunoscută sub numele de mașină de stare OpenGL.
Cele mai multe comenzi OpenGL primitive, fie problema la conducta grafica, sau
configura felul în care aceste procese de conducte de primitive. Înainte de
introducerea OpenGL 2.0, fiecare etapă din conducta efectuat o funcție fixă și a
fost configurabil numai în limite restranse. OpenGL 2.0 oferă mai multe etape, care
sunt pe deplin programabile folosind GLSL.
OpenGL este API procedural de nivel mic, care necesită ca un programator să
impună măsurile exacte necesare pentru a face o scena. Acest lucru contrastează cu
alte API-uri, în care un programator are nevoie doar pentru a descrie o scenă și
poate lăsa biblioteca și gestiona detalile și redand finalul scenei. OpenGL's de nivel
mic, impune programatori să aibă o bună cunoaștere a conducta grafică, dar, de
asemenea, oferă o anumită libertatea de a pune în aplicare algoritmi noi de redare.
OpenGL are un istoric de influente de la dezvoltarea acceleratoarelor 3D,
promovănd un nivel de bază de funcționalitate, care este acum în comun cu nivelul
hardwareului de consum.

3
 Listingul programului:
#include <windows.h>
#include "gl.h"
#pragma comment(lib,"opengl32.lib")
#include "glu.h"
#pragma comment(lib,"glu32.lib")
#include "glaux.h"
#pragma comment(lib,"glaux.lib")
#include <math.h>
#define RADGRAD 0.0174532925199433
#define MAXH 150
#define MAXS 150
static GLuint ln;
static GLuint lns[3];

class cone0
{
protected:
int nh;
int ns;
double c[MAXH][MAXS][3];
public:
cone0(int, int);
void drawcon();
};

cone0::cone0(int heightsegm, int sectors)

{
int i,j;
nh=heightsegm;
ns=sectors;

if(nh>MAXH) nh=MAXH;
else if(nh<1) nh=10;

if(ns>MAXS) ns=MAXS;
else if(ns<3) ns=10;

double hstep=0.35/nh;
double astep=-360./ns;
double hcur,acur,rcur;

hcur=0.0;
double h=0.09;

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

{
hcur+=hstep;
acur=0.0;
rcur=hcur;
for(j=0; j<ns; j++)
{
c[i][j][0]=rcur*cos(RADGRAD*acur)+h;
c[i][j][1]=rcur*sin(RADGRAD*acur)-h;
c[i][j][2]=rcur;
acur+=astep;
}h+=0.09;
}
}

void cone0::drawcon()
4
{
int i,j;

glBegin(GL_TRIANGLE_FAN);
glVertex3d(0.,0.,0.);
for(j=0; j<ns; j++)
glVertex3dv(c[j][0]);
glVertex3dv(c[0][0]);
glEnd();

for(i=0; i<nh-1; i++)

{
glBegin(GL_TRIANGLE_STRIP);
for(j=0; j<ns; j++)
{
glVertex3dv(c[i+1][j]);
glVertex3dv(c[i][j]);
}
glVertex3dv(c[i+1][0]);
glVertex3dv(c[i][0]);
glEnd();
}
}

static cone0 c1(10,20);

//static cone0 c2(10,30);

void MyLists()
{
glNewList(ln+0,GL_COMPILE);
//Axa x
glBegin(GL_LINES);
glColor3d(0.,0.,0.);
glVertex3d(-5.5,0.,0.);
glColor3d(1.,0.,0.);
glVertex3d(5.5,0.,0.);
glEnd();
glEndList();

glNewList(ln+1,GL_COMPILE);
//Axa y
glBegin(GL_LINES);
glColor3d(0.,0.,0.);
glVertex3d(0.,-5.5,0.);
glColor3d(0.,1.,0.);
glVertex3d(0.,5.5,0.);
glEnd();
glEndList();

glNewList(ln+0,GL_COMPILE);
//Axa z
glBegin(GL_LINES);
glColor3d(0.,0.,0.);
glVertex3d(0.,0.,-5.5);
glColor3d(0.,0.,1.);
glVertex3d(0.,0.,5.5);
glEnd();
glEndList();
}

void CALLBACK resize(int width, int height)

{

5
 GLuint wp = width<height ? width-20 : height-20;
glViewport(10,10,wp,wp);

glMatrixMode(GL_PROJECTION);
glLoadIdentity();

glOrtho(-6.2,6.2,-6.2,6.2, 2., 12.);

glMatrixMode(GL_MODELVIEW);
}

double fi=0;

void CALLBACK display(void)

{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

glPushMatrix();
glTranslated(0.,0.,-6.0);
glRotated(35.+fi, 1., 0., 0.);
glRotated(35.+fi, 0., 1., 0.);
fi+=0.09;
glPointSize(10.0f);
glEnable(GL_POINT_SMOOTH);

glBegin(GL_POINTS);
glColor3d(0,0,0);
glVertex3d(0.f,0.f,0.f);
glEnd();

glDisable(GL_POINT_SMOOTH);

glLineWidth(2.0f);
glEnable(GL_LINE_SMOOTH);

glBegin(GL_LINES);
//Axa X
//glCallList(ln+0);
glColor3d(0.,0.,0.);
glVertex3d(-5.5,0.,0.);
glColor3d(1.,0.,0.);
glVertex3d(5.5,0.,0.);
//Axa Y
//glCallList(ln+1);
glColor3d(0.,0.,0.);
glVertex3d(0.,-5.5,0.);
glColor3d(0.,1.,0.);
glVertex3d(0.,5.5,0.);
//Axa Z
//glCallList(ln+2);
glColor3d(0.,0.,0.);
glVertex3d(0.,0.,-5.5);
glColor3d(0.,0.,1.);
glVertex3d(0.,0.,5.5);
glEnd();

//Con X
glColor3d(1,0,0);
glPushMatrix();
glTranslated(5.3f,0.0f,0.0f);
glRotated(90, 0.0f, 1.0f, 0.0f);
auxSolidCone(0.1f,0.2f);
6
 glPopMatrix();

//Con Y
glColor3d(0,1,0);
glPushMatrix();
glTranslated(0.0f, 5.3f, 0.0f);
glRotated(-90, 1.0f, 0.0f, 0.0f);
auxSolidCone(0.1f,0.2f);
glPopMatrix();

//Con Z
glColor3d(0,0,1);
glPushMatrix();
glTranslated(0.0f, 0.0f, 5.3f);
auxSolidCone(0.1f,0.2f);
glPopMatrix();

glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
//desenarea conurilor
glPushMatrix();
glTranslated(0.0f, 0.0f, 0.0f);
glScaled(2.,2.,5.);
glColor3d(1.,0.,0.);
c1.drawcon();
glPopMatrix();

glPushMatrix();
glTranslated(0.0f, 0.0f, 0.0f);
glScaled(-2.,-2.,5.);
glColor3d(0.,1.,0.);
c1.drawcon();
glPopMatrix();

glPushMatrix();
glTranslated(0.0f, 0.0f, 0.0f);
glScaled(2.,2.,-5.);
glColor3d(0.,0.,1.);
c1.drawcon();
glPopMatrix();

glPushMatrix();
glTranslated(0.0f, 0.0f, 0.0f);
glScaled(-2.,-2.,-5.);
glColor3d(1.,1.,0.);
c1.drawcon();
glPopMatrix();

//desenarea liniilor
for(float i=-1.75; i<0; i+=0.01)
{
glLineWidth(1.3f);
glEnable(GL_LINE_SMOOTH);

glPushMatrix();
glTranslated(0.0f, 0.0f, float(1.75+i));
glRotated(-45.0f, 0.0f, 0.0f, 1.0f);
glBegin(GL_LINES);

glColor3d(1.,0.,1.);
glVertex3d(1.75+i,0.,0.);
7
 glColor3d(1.,0.,1.);
glVertex3d(-1.75-i,0.,0.);

glEnd();
glPopMatrix();
}
///////////////////////////////////////////////////////

for(float i=0; i<1.75; i+=0.01)

{
glPushMatrix();
glTranslated(0.0f, 0.0f, float(-1.75+i) );
glRotated(-45.0f, 0.0f, 0.0f, 1.0f);
glBegin(GL_LINES);
//linia

glColor3d(0.,1.,1.);
glVertex3d(1.75-i,0.,0.);
glColor3d(0.,1.,1.);
glVertex3d(-1.75+i,0.,0.);

glEnd();
glPopMatrix();
}
glPopMatrix();

auxSwapBuffers();
}

void main()
{
auxInitPosition(0,0,500,500);

auxInitDisplayMode(AUX_RGB|AUX_DEPTH|AUX_DOUBLE);

auxInitWindow((LPCWSTR)("OpenGL"));

auxIdleFunc(display);

auxReshapeFunc(resize);

glEnable(GL_ALPHA_TEST);

glEnable(GL_DEPTH_TEST);

glEnable(GL_COLOR_MATERIAL);

glEnable(GL_LIGHTING);

glEnable(GL_LIGHT0);

float pos[4] = {3,3,3,1};

float dir[3] = {-1,-1,-1};
glLightfv(GL_LIGHT0, GL_POSITION, pos);
glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, dir);

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

glClearColor(1.f, 1.f, 1.f, 1.f);

8
 auxMainLoop(display);
}

Rezultatul:

Concluzie:
9
 În lucrarea dată am folosit bibliotecile OpenGL, care sunt foarte importante
la desenarea diferitor figuri.

10