Open GL

///////CRTANJE FIGURA
void CGLRenderer::DrawPyramid(double size)

{
double h = 0.63485477 * size;
double a = size / 2;
double s = sqrt(h * h + a * a);
glBegin(GL_TRIANGLES);
glNormal3f(0.0, a/s, h/s);
glTexCoord2f(1.5, 3.0); glVertex3f(0.0, h, 0.0);
glTexCoord2f(0.0, 0.0); glVertex3f(-a, 0.0, a);
glTexCoord2f(3.0, 0.0); glVertex3f(a, 0.0, a);
glNormal3f(h/s, a/s, 0.0);
glTexCoord2f(0.0, 0.0); glVertex3f(a, 0.0, a);
glTexCoord2f(3.0, 0.0); glVertex3f(a, 0.0, -a);
glNormal3f(0.0, a/s, -h/s);
glTexCoord2f(0.0, 0.0); glVertex3f(a, 0.0, -a);
glTexCoord2f(3.0, 0.0); glVertex3f(-a, 0.0, -a);
glNormal3f(-h/s, a/s, 0.0);
glTexCoord2f(0.0, 0.0); glVertex3f(-a, 0.0, -a);
glTexCoord2f(3.0, 0.0); glVertex3f(-a, 0.0, a);
glEnd();
}
void CGLRenderer::DrawGlSphere(double radius, int slices, int stacks)
{
double pi = acos(-1.0);
double dTheta = pi / (2 * stacks);
double dPhi = 2 * pi / slices;
double ds = 1.0 / slices;
double dt = 0.5 / stacks;
double x, y, z;
for(int i = 0; i < stacks; i++)
{
glBegin(GL_QUAD_STRIP);
for(int j
{
x
y
z
= 0; j < slices; j++)

= radius*cos(i*dTheta)*cos(j*dPhi);
= radius*sin(i*dTheta);
= radius*cos(i*dTheta)*sin(j*dPhi);
glTexCoord2f(1.0 - j*ds, 0.5 + i*dt);

glNormal3f(x/radius, y/radius, z/radius);
glVertex3f(x, y, z);
x = radius*cos((i+1)*dTheta)*cos(j*dPhi);
y = radius*sin((i+1)*dTheta);
z = radius*cos((i+1)*dTheta)*sin(j*dPhi);
glTexCoord2f(1.0 - j*ds, 0.5 + (i+1)*dt);
x = radius*cos(i*dTheta)*cos((j+1)*dPhi);
y = radius*sin(i*dTheta);
z = radius*cos(i*dTheta)*sin((j+1)*dPhi);
glTexCoord2f(1.0 - (j+1)*ds, 0.5 + i*dt);
x = radius*cos((i+1)*dTheta)*cos((j+1)*dPhi);
z = radius*cos((i+1)*dTheta)*sin((j+1)*dPhi);
glTexCoord2f(1.0 - (j+1)*ds, 0.5 + (i+1)*dt);
}
glEnd();
}
dTheta = -dTheta;
for(int i = 0; i < stacks; i++)
{
for(int j
{
x
y
z
= 0; j < slices; j++)

= radius*cos((i+1)*dTheta)*cos(j*dPhi);
= radius*sin((i+1)*dTheta);
= radius*cos((i+1)*dTheta)*sin(j*dPhi);
glTexCoord2f(1.0 - j*ds, 0.5 - (i+1)*dt);

x = radius*cos(i*dTheta)*cos(j*dPhi);
z = radius*cos(i*dTheta)*sin(j*dPhi);
glTexCoord2f(1.0 - j*ds, 0.5 - i*dt);
x = radius*cos((i+1)*dTheta)*cos((j+1)*dPhi);
z = radius*cos((i+1)*dTheta)*sin((j+1)*dPhi);
glTexCoord2f(1.0 - (j+1)*ds, 0.5 - (i+1)*dt);
x = radius*cos(i*dTheta)*cos((j+1)*dPhi);
z = radius*cos(i*dTheta)*sin((j+1)*dPhi);
glTexCoord2f(1.0 - (j+1)*ds, 0.5 - i*dt);
}
glEnd();
}
}
void CGLRenderer::DrawPillar(double x, double y, double z)

{
glBegin(GL_QUADS);
glNormal3f(0.0, 0.0, 1.0);
glTexCoord2f(0.5, 0.5); glVertex3f(0.0,
glTexCoord2f(0.625, 0.5); glVertex3f(x,
0.0, z);
0.0, z);
y, z);
y, z);
glNormal3f(1.0, 0.0, 0.0);

glTexCoord2f(0.625, 0.5); glVertex3f(x, 0.0, z);
glTexCoord2f(0.75, 0.5); glVertex3f(x, 0.0, 0.0);
glTexCoord2f(0.75, 1.0); glVertex3f(x, y, 0.0);
glTexCoord2f(0.625, 1.0); glVertex3f(x, y, z);
glNormal3f(0.0, 0.0, -1.0);
glTexCoord2f(0.875, 0.5); glVertex3f(0.0, 0.0, 0.0);
glTexCoord2f(0.875, 1.0); glVertex3f(0.0, y, 0.0);
glNormal3f(-1.0, 0.0, 0.0);
glTexCoord2f(1.0, 0.5); glVertex3f(0.0, 0.0, z);
glTexCoord2f(1.0, 1.0); glVertex3f(0.0, y, z);
glEnd();
}
void CGLRenderer::DrawBox(double a, double b, double c)

{
double a2 = a / 2;
double b2 = b / 2;
double c2 = c / 2;
glBegin(GL_QUADS);
glNormal3f(0.0, 0.0, 1.0);
glVertex3f(-a2, -b2, c2);
glVertex3f(a2, -b2, c2);
glVertex3f(a2, b2, c2);

glVertex3f(-a2, b2, c2);
glNormal3f(1.0, 0.0, 0.0);
glVertex3f(a2, -b2, -c2);
glVertex3f(a2, b2, -c2);
glNormal3f(0.0, 0.0, -1.0);
glVertex3f(-a2, -b2, -c2);
glVertex3f(-a2, b2, -c2);
glNormal3f(-1.0, 0.0, 0.0);
glNormal3f(0.0, 1.0, 0.0);
glNormal3f(0.0, -1.0, 0.0);
glEnd();
}
void CGLRenderer::DrawCylinder(double r, double h, int steps)

{
double pi = acos(-1.0);
double angleStep = 2*pi/steps;
double currentAngle;
for (int i = 0; i <= steps; i++)
{
currentAngle = i*angleStep;
glNormal3f(cos(currentAngle), 0.0, sin(currentAngle));
glVertex3f(r*cos(currentAngle), 0.0, r*sin(currentAngle));
glVertex3f(r*cos(currentAngle), h, r*sin(currentAngle));
}
glEnd();
}
void CGLRenderer::DrawTrapezoid(float a, float b, float h, float H)

{
float x = (a - b) / 2;
float s = sqrt(h * h + x * x);
glBegin(GL_QUADS);
glNormal3f(0.0, 0.0, 1.0);
glVertex3f(0.0, 0.0, H);
glVertex3f(a, 0.0, H);
glVertex3f(x + b, h, H);
glVertex3f(x, h, H);
glNormal3f(h/s, x/s, 0.0);
glVertex3f(a, 0.0, 0.0);
glVertex3f(x + b, h, 0.0);
glNormal3f(0.0, 0.0, -1.0);
glVertex3f(0.0, 0.0, 0.0);
glVertex3f(x, h, 0.0);
glNormal3f(-h/s, x/s, 0.0);
glVertex3f(0.0, 0.0, 0.0);
glNormal3f(0.0, -1.0, 0.0);
glVertex3f(0.0, 0.0, 0.0);
glNormal3f(0.0, 1.0, 0.0);
glEnd();
}
void CGLRenderer::DrawRing(float a, float b, float h, float H)

{
glPushMatrix();
DrawTrapezoid(a, b, h, H);
for (int i = 0; i < 5; i++)
{
glTranslatef(a, 0.0, 0.0);
glRotatef(60.0, 0.0, 0.0, 1.0);

DrawTrapezoid(a, b, h, H);
}
glPopMatrix();
}
void CGLRenderer::COMPLEXDrawBox(double a, double b, double c)

{
double step = 0.025;//korak deljenja na 1.0pixel crta 10 manjih trouglo
va
double i=0;
double j=0;
float faktorA, faktorB;
faktorA = a/2;
faktorB = b/2;
glBegin(GL_TRIANGLES);//ovde crtam preko trouglova, moze i GL_TRIANGLE_F
AN ali se drugacije definise normala
//donja strana
glNormal3f(0.0, -1.0, 0.0);
for(i=0; i<a; i+=step)
{
for(j=0; j<b; j+=step)
{
glVertex3f(i, 0.0, j);
glVertex3f(i+step, 0.0, j);
glVertex3f(i+step, 0.0, j+step);
glVertex3f(i, 0.0, j+step);
glVertex3f(i, 0.0, j);
glVertex3f(i+step, 0.0, j+step);
}
}
//gore
glNormal3f(0.0, 1.0, 0.0);
{
for(j=0; j<b; j+=step)
{
glTexCoord2f((i+step)/faktorA, (j+step)/faktorB)
;//ista koordinata kao Vertex samo podeljena faktorom
glVertex3f(i+step, c, j+step);
glTexCoord2f((i+step)/faktorA, j/faktorB);//ista
koordinata kao Vertex samo podeljena faktorom
glVertex3f(i+step, c, j);
glTexCoord2f(i/faktorA, j/faktorB);//ista koordi
nata kao Vertex samo podeljena faktorom
glVertex3f(i, c, j);
glTexCoord2f(i/faktorA, (j+step)/faktorB);//ista
koordinata kao Vertex samo podeljena faktorom
glVertex3f(i, c, j+step);
glTexCoord2f((i+step)/faktorA, (j+step)/faktorB)
;//ista koordinata kao Vertex samo podeljena faktorom
glVertex3f(i+step, c, j+step);
glTexCoord2f(i/faktorA, j/faktorB);//ista koordi
nata kao Vertex samo podeljena faktorom
glVertex3f(i, c, j);
}
}
//levo
glNormal3f(-1.0, 0.0, 0.0);
for(i=0; i<b; i+=step)
{
for(j=0; j<c; j+=step)
{
glVertex3f(0.0, j, i);
glVertex3f(0.0, j+step, i+step);
glVertex3f(0.0, j+step, i);
glVertex3f(0.0, j, i+step);
glVertex3f(0.0, j+step, i+step);
glVertex3f(0.0, j, i);
}
}
//desno
glNormal3f(1.0, 0.0, 0.0);
for(i=0; i<b; i+=step)
{
{
glVertex3f(a, j, i);
glVertex3f(a, j+step, i);
glVertex3f(a, j+step, i+step);
glVertex3f(a, j, i+step);
glVertex3f(a, j, i);
glVertex3f(a, j+step, i+step);
}
}
//nazad
glNormal3f(0.0, 0.0, -1.0);
{
{
glVertex3f(i, j, 0.0);
glVertex3f(i+step, j+step, 0.0);
glVertex3f(i+step, j, 0.0);
glVertex3f(i, j+step, 0.0);
}
}
//napred
glNormal3f(0.0, 0.0, 1.0);
{

{
glVertex3f(i, j, b);
glVertex3f(i+step, j, b);
glVertex3f(i+step, j+step, b);
glVertex3f(i, j+step, b);
glVertex3f(i, j, b);
glVertex3f(i+step, j+step, b);
}
}
glEnd();
}
void CGLRenderer::DrawWalls()
{
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, m_wal_id);
glPushMatrix();
glColor3f(0.8, 0.8, 0.8);
DrawWall(20);
glColor3f(0.7, 0.7, 0.7);
glRotatef(270.0, 0.0, 1, 0);
DrawWall(20);
glBindTexture(GL_TEXTURE_2D, m_floor_id);
glColor3f(0.5, 0.5, 0.5);
glRotatef(270.0, 1, 0, 0);
DrawWall(20);
glPopMatrix();
glDisable(GL_TEXTURE_2D);
}
void CGLRenderer::SIMPLEDrawWall(double a)
{
glBegin(GL_QUADS);
glVertex3d(0, 0, 0);
glVertex3d(a, 0, 0);
glVertex3d(a, a, 0);
glVertex3d(0, a, 0);
glEnd();
}
void CGLRenderer::COMPLEXDrawWall(double a)
{
float faktor;
faktor = a/6;
//slozenije iscrtavanje sa deljenjem za 5-tu vezbu
double step;
step = 0.05;
glNormal3f(0.0, 0.0, 1.0);
glBegin(GL_TRIANGLES);
for(double i=0; i< a; i+=step)

{
for(double j=0; j< a; j+=step)
{
glTexCoord2f(i/faktor, j/faktor);
glTexCoord2f((i+step)/faktor,j/faktor);
glTexCoord2f(i/faktor, (j+step)/faktor);
glTexCoord2f((i+step)/faktor, j/faktor);
glTexCoord2f((i+step)/faktor, (j+step)/faktor);
glTexCoord2f(i/faktor, (j+step)/faktor);
}
}
glEnd();
}
void CGLRenderer::DrawLampTop()
{
glColor3f(0,0.0,1.0);
glTranslatef(-0.2,0,-0.1);
DrawBox(0.5,0.3,0.3);
//glutSolidSphere(0.2,10.0,10.0);
glTranslatef(0.8,0.15,0.15);
GLdouble niz[4] = {-1,0,0,0.1};
glClipPlane(GL_CLIP_PLANE0, niz);
glEnable(GL_CLIP_PLANE0);
glutSolidSphere(0.4,10.0,10.0);
glDisable(GL_CLIP_PLANE0);
SetBulbMaterial();
Sijalica();
}
void CGLRenderer::DrawVaza()
{
glPushMatrix();
glTranslatef(4, 0.5, 2);
GLdouble niz[4] = {0,-1,0,0.1};
glClipPlane(GL_CLIP_PLANE0, niz);
glEnable(GL_CLIP_PLANE0);
glTexCoord2f(1, 1);
glDisable(GL_CLIP_PLANE0);
glPopMatrix();
}
///KUPA
How about glutSolidCone or glutWireCone.
You can also use gluCylinder with one end having a radius of zero.
void WINAPI gluCylinder(
GLUquadric *qobj,
GLdouble baseRadius,
GLdouble topRadius,
GLdouble height,
GLint slices,
GLint stacks
);
///
GLUquadricObj *qo;
qo = gluNewQuadric();
if (qo==NULL) /* error ... */
gluQuadricDrawStyle(qo,GLU_FILL);
gluQuadricNormals(qo,GLU_SMOOTH);
gluQuadricOrientation(qo,GLU_OUTSIDE);
gluCylinder(qobj,baseRadius,topRadius,height,segments,1);
gluDeleteQuadric(qo);
///
void CGLRenderer::DrawCone(double radius, int vcount, double lenght)
{
glBegin(GL_TRIANGLE_FAN);
glVertex3f(0.0f,0.0f,0.0f);
for(i=0; i<vcount; ++i);
{
glVertex3f(radius*sin(i*PI/vcount),radius*cos(i*PI/vcount),-leng
th);
}
glEnd();
}
///
////KRETANJE KROZ SCENU
ON_WM_KEYDOWN()
void CGLView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
// TODO: Add your message handler code here and/or call default
CView::OnKeyDown(nChar, nRepCnt, nFlags);
if(nChar == 'A')
{
m_glRenderer.ugaoPostolja += 10;
Invalidate();
}
if (nChar == VK_RIGHT)
{
double hip;
double tempz = m_glRenderer.lookz;
double tempx = m_glRenderer.lookx;
tempz -= 0.2;
hip = pow(m_glRenderer.lookx, 2) + pow(m_glRenderer.lookz, 2);
tempx = sqrt(hip - pow(tempz, 2));
m_glRenderer.lookz = tempz;
m_glRenderer.lookx = tempx;
Invalidate();
}
}
////OSVETLJENJE I MATERIJALI
void CGLRenderer::SvetloSijalica()
{
GLfloat l_ambient[] = {0.5, 0.5, 0.0, 1.0};//ambijentalno
GLfloat l_dif[] = {1.0, 1.0, 0.0, 1.0};//difuzno
GLfloat l_spec[] = {1.0, 1.0, 0.0, 1.0};//spekularno
glLightfv(GL_LIGHT1, GL_AMBIENT, l_ambient);//postavljanje ambijentalnog
glLightfv(GL_LIGHT1, GL_DIFFUSE, l_dif);//postavljanje difuznog
glLightfv(GL_LIGHT1, GL_SPECULAR, l_spec);//postavljanje spekularnog
float l_pos[] = {0.0, 0.0, 0.0, 1.0};//pozicija (4-ti parametar mora na
1 ako je lokalno, 0=u beskonacnosti OpenGL str.127 pri kraju za w parametar
glLightfv(GL_LIGHT1, GL_POSITION, l_pos);// postavljanje pozicije
glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, 1);//konstantno slabljenje
glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, 0.5);//linearno slabljenje
glLightf(GL_LIGHT1, GL_QUADRATIC_ATTENUATION, 0.0);//kvadratno slabljenj
e
//OpenGL str. 128 ruga polovina
float dir[] = {1.0,0.0, 0.0};//smer osvetljenja
//posto moja clip ravan sece loptu po x osi onda smer treba da bude u ne
gativnoj y osi (na dole)
glLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, dir);//smer osvetljenja
glLightf(GL_LIGHT1, GL_SPOT_CUTOFF, 22.5);//ugao
glLightf(GL_LIGHT1, GL_SPOT_EXPONENT, 2.0);//eksponent opadanja
//OpenGL str.129
glEnable(GL_LIGHT1);//ukljucivanje svetlosti
}
void CGLRenderer::SetLightModel()//postavljanje svetlosnog modela (globalno ambi

jentalno itd..)
{
//globalno ambijentalno
GLfloat ambient[] = {0.2, 0.2, 0.2, 1.0};
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_FALSE);//ovako se trazi u
zadatku
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);//ovako se trazi u zadat
ku
glEnable(GL_LIGHTING);//ukljucivanje osvetljenja generalno
//lokalno
GLfloat l_ambient[] = {0.2, 0.2, 0.2, 1.0};//abmijentalna zadata u zadat
ku
GLfloat l_dif[] = {1.0, 1.0, 1.0, 1.0};//difuzna zadata u zadatku
GLfloat l_spec[] = {1.0, 1.0, 1.0, 1.0};//spekularna zadata u zadatku
glLightfv(GL_LIGHT0, GL_AMBIENT, l_ambient);//selekcija
glLightfv(GL_LIGHT0, GL_DIFFUSE, l_dif);//selekcija
glLightfv(GL_LIGHT0, GL_SPECULAR, l_spec);//selekcija
float l_pos[] = {lx, ly, lz, 1.0};//pozicija (trazi se iznad stola ali u
daljeno pod uglom)
glLightfv(GL_LIGHT0, GL_POSITION, l_pos);//selekcija pozicija (postavlja
nje)
glEnable(GL_LIGHT0);//uljkucivanje lokalnog svetla
}
void CGLRenderer::SijalicaMaterial()
{
GLfloat ambient[] = {0.2, 0.0, 0.0, 1.0};
glMaterialfv(GL_FRONT, GL_AMBIENT, ambient);
GLfloat dif[] = {1, 1, 0.5, 1.0};
glMaterialfv(GL_FRONT, GL_DIFFUSE, dif);
GLfloat spec[] = {1.0, 1.0, 1.0, 1.0};
glMaterialfv(GL_FRONT, GL_SPECULAR, spec);
glMaterialf(GL_FRONT, GL_SHININESS, 4.0);
void CGLRenderer::SetWallMaterial()//popunjavanje materija za zid

{
GLfloat ambient[] = {0.2, 0.2, 0.2, 1.0};
GLfloat dif[] = {0.8, 0.8, 0.8, 1.0};
GLfloat spec[] = {1.0, 1.0, 1.0, 1.0};
}
void CGLRenderer::SetWoodMaterials()//popunjavanje materija za drvo
{
GLfloat ambient[] = {0.5, 0.2, 0.02, 1.0};
GLfloat dif[] = {0.7, 0.35, 0.11, 1.0};
GLfloat spec[] = {1.0, 1.0, 1.0, 1.0};
}
void CGLRenderer::SetRedMetal()//popunjavanje materija za crveni metal \m/

{
GLfloat ambient[] = {0.2, 0.0, 0.0, 1.0};
GLfloat dif[] = {0.8, 0.0, 0.0, 1.0};
GLfloat spec[] = {1.0, 1.0, 1.0, 1.0};
}
/////OSNOVNE F-je
void CGLRenderer::DrawScene(CDC *pDC)
{
wglMakeCurrent(pDC->m_hDC, m_hrc);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//Z-buffer OpenGL str
.94
glEnable(GL_DEPTH_TEST);//Z-buffer OpenGL str.94
//---------------------------------
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0, 0.0, 0.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(
lookx, looky, lookz, 0.0, 0.0, 0.0,
SetLightModel();//postavljanje svetlosnog modela
....
....
....
//--------------------------------SwapBuffers(pDC->m_hDC);
wglMakeCurrent(NULL, NULL);
}
void CGLRenderer::Reshape(CDC *pDC, int w, int h)

{
//--------------------------------glViewport(0,0,(GLsizei) w, (GLsizei) h);
double aspect = (double) w / (double) h;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0, aspect, 0.1, 100);
//--------------------------------wglMakeCurrent(NULL, NULL);
}
bool CGLRenderer::CreateGLContext(CDC* pDC)
{
ugaoKrak1 = 30;;
ugaoKrak2 = -90;
ugaoPostolja = 0;
pozStola = 0;
ugaolampe = 0;
ugaolampe2 = 0;
lookx = 15.0;
looky = 9.0;
lookz = 13.0;
lx = 20;
ly = 11.5;
lz = 3;
0.0, 1.0, 0.0);
PIXELFORMATDESCRIPTOR pfd ;
memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
pfd.nVersion = 1;
pfd.dwFlags
= PFD_DOUBLEBUFFER | PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WIN
DOW;
pfd.iPixelType
pfd.cColorBits
pfd.cDepthBits
pfd.iLayerType
=
=
=
=
PFD_TYPE_RGBA;
32;
24;
PFD_MAIN_PLANE;
int nPixelFormat = ChoosePixelFormat(pDC->m_hDC, &pfd);

if (nPixelFormat == 0) return false;
BOOL bResult = SetPixelFormat (pDC->m_hDC, nPixelFormat, &pfd);
if (!bResult) return false;
m_hrc = wglCreateContext(pDC->m_hDC);
if (!m_hrc) return false;
return true;
}
void CGLRenderer::PrepareScene(CDC *pDC)

{
//---------------------------------
glClearColor(1.0, 1.0, 1.0, 0.0);

PrepareTexture();//Priprema texura
glEnable(GL_DEPTH_TEST);
//glEnable(GL_NORMALIZE);
//--------------------------------wglMakeCurrent(NULL, NULL);
}
void CGLRenderer::OnDestroy()
{
glDeleteTextures(1,&m_tab_id);
glDeleteTextures(1,&m_wal_id);
glDeleteTextures(1,&m_floor_id);
////TEXTURE
void CGLRenderer::PrepareTextureMOJE()
{
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
//ucitavanje texture stola
glGenTextures(1, &m_tab_id);//generisanje jedinstvenog id-a za texturu i
njegovo pamcenje
glBindTexture(GL_TEXTURE_2D, m_tab_id);//kreiranje i aktiviranje objekta
textura
AUX_RGBImageRec *TableTex;
TableTex = auxDIBImageLoad("ASHSEN512.bmp");
//ukljucivanje LINEARNE teksture
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_L
INEAR);
//glTexImage2D(GL_TEXTURE_2D, 0, 3, TableTex->sizeX, TableTex->sizeY, 0,
GL_RGB, GL_UNSIGNED_BYTE, TableTex->data);//ovako se definise samo za jednu bit
mapu
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, TableTex->sizeX, TableTex->sizeY, GL
_RGB, GL_UNSIGNED_BYTE, TableTex->data);//pomocna funkcija koja pravi i mipmape
//ucitavanje texture zida (slicno kao sto)

glGenTextures(1, &m_wal_id);
glBindTexture(GL_TEXTURE_2D, m_wal_id);
AUX_RGBImageRec *WallTex;
WallTex = auxDIBImageLoad("Wall512.bmp");
INEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
//glTexImage2D(GL_TEXTURE_2D, 0, 3, WallTex->sizeX, WallTex->sizeY, 0, G
L_RGB, GL_UNSIGNED_BYTE, WallTex->data);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, WallTex->sizeX, WallTex->sizeY, GL_R
GB, GL_UNSIGNED_BYTE, WallTex->data);
//ucitavanje poda (slicno kao sto)
glGenTextures(1, &m_floor_id);
glBindTexture(GL_TEXTURE_2D, m_floor_id);
AUX_RGBImageRec *FloorTex;
FloorTex = auxDIBImageLoad("PAT39.bmp");
INEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
//glTexImage2D(GL_TEXTURE_2D, 0, 3, FloorTex->sizeX, FloorTex->sizeY, 0,
GL_RGB, GL_UNSIGNED_BYTE, FloorTex->data);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, FloorTex->sizeX, FloorTex->sizeY, GL
_RGB, GL_UNSIGNED_BYTE, FloorTex->data);
glGenTextures(1, &m_oval_id);
glBindTexture(GL_TEXTURE_2D, m_oval_id);
AUX_RGBImageRec *OvalTex;
OvalTex = auxDIBImageLoad("oval2.bmp");
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, OvalTex->sizeX, OvalTex->sizeY, GL_R
GB, GL_UNSIGNED_BYTE, OvalTex->data);
//////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
#include "StdAfx.h"
#include "GLRenderer.h"
#include
#include
#include
#include
"gl.h"
"glu.h"
"glaux.h"
"glut.h"
#include <math.h>
#include <stdlib.h>
CGLRenderer::CGLRenderer(void)
{
texIDs = new unsigned int[2];
angle = 0.0;
}
CGLRenderer::~CGLRenderer(void)
{
delete [] texIDs;
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////
bool CGLRenderer::CreateGLContext(CDC* pDC)
{
PIXELFORMATDESCRIPTOR pfd;
memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DOUBLEBUFFER | PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW
;
pfd.iPixelType
pfd.cColorBits
pfd.cDepthBits
pfd.iLayerType
=
=
=
=
PFD_TYPE_RGBA;
32;
24;
PFD_MAIN_PLANE;
int nPixelFormat = ChoosePixelFormat(pDC->m_hDC, &pfd);

if (nPixelFormat == 0) return false;
BOOL bResult = SetPixelFormat(pDC->m_hDC, nPixelFormat, &pfd);
if (!bResult) return false;
m_hrc = wglCreateContext(pDC->m_hDC);
if (!m_hrc) return false;
return true;
}
void CGLRenderer::PrepareScene(CDC* pDC)
{
glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
glClearColor(0.0, 0.0, 0.0, 1.0);
PrepareTextures();
}
void CGLRenderer::Reshape(CDC* pDC, int w, int h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(35.0, (double)w / (double)h, 0.01, 250.0);
}
void CGLRenderer::DestroyScene(CDC* pDC)
{
glDeleteTextures(2, texIDs);
wglMakeCurrent(NULL,NULL);
if(m_hrc)
{
wglDeleteContext(m_hrc);
m_hrc = NULL;
}
}
void CGLRenderer::DrawScene(CDC* pDC)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
gluLookAt(5.0, 4.0, 4.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
SetLight();
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, texIDs[0]);
INEAR);
DrawRoom();
glPushMatrix();
glTranslatef(-1.5, 0.0, 2.0);
DrawPillar(1.0, 4.0, 1.0);
glPopMatrix();
glPushMatrix();
glTranslatef(1.5, 0.0, -2.0);
DrawPillar(1.0, 4.0, 1.0);
glPopMatrix();
glPushMatrix();
glTranslatef(-1.0, 0.0, -0.2);
glBindTexture(GL_TEXTURE_2D, texIDs[1]);
INEAR);
DrawSarcophagus(2.0, 1.0, 1.0);
glPopMatrix();
glDisable(GL_TEXTURE_2D);
glRotatef(-angle, 1.0, 0.0, 0.0);
SetSarcophagusTopMaterial();
DrawSarcophagusTop(2.0, 0.2, 1.0);
SetNormalMaterial();
glFlush();
SwapBuffers(pDC->m_hDC);
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////
void CGLRenderer::DrawRoom()
{
glPushMatrix();
glBegin(GL_QUADS);
glNormal3f(0.0, 0.0, 1.0);
0.0,
0.0,
8.0,
8.0,
0.0);
0.0);
0.0);
0.0);
glNormal3f(1.0, 0.0, 0.0);

0.0,
8.0,
8.0,
0.0,
0.0);
0.0);
8.0);
8.0);
glNormal3f(0.0, 1.0, 0.0);

0.0,
0.0,
0.0,
0.0,
0.0);
8.0);
8.0);
0.0);
glEnd();
glPopMatrix();
}
void CGLRenderer::DrawPillar(double x, double y, double z)
{
glBegin(GL_QUADS);
glNormal3f(0.0, 0.0, 1.0);
0.0, z);
0.0, z);
y, z);
y, z);
glNormal3f(1.0, 0.0, 0.0);

glNormal3f(0.0, 0.0, -1.0);
glNormal3f(-1.0, 0.0, 0.0);
glEnd();
}
void CGLRenderer::DrawSarcophagus(double x, double y, double z)
{
glBegin(GL_QUADS);
glNormal3f(0.0, 0.0, 1.0);
glNormal3f(1.0, 0.0, 0.0);

glNormal3f(0.0, 0.0, -1.0);
glNormal3f(-1.0, 0.0, 0.0);
0.0, 0.0);
0.0, z);
y, z);
y, 0.0);
glEnd();
}
void CGLRenderer::DrawSarcophagusTop(double x, double y, double z)
{
glBegin(GL_QUADS);
glNormal3f(0.0, 0.0, 1.0);
glVertex3f(0.0, 0.0, z);
glVertex3f(x, 0.0, z);
glVertex3f(0.0, y, z);
glNormal3f(1.0, 0.0, 0.0);
glVertex3f(x, 0.0, 0.0);
glVertex3f(x, y, 0.0);
glNormal3f(0.0, 0.0, -1.0);
glVertex3f(0.0, 0.0, 0.0);
glVertex3f(0.0, y, 0.0);
glNormal3f(-1.0, 0.0, 0.0);
glVertex3f(0.0, 0.0, 0.0);
glNormal3f(0.0, 1.0, 0.0);
glNormal3f(0.0, -1.0, 0.0);
glVertex3f(0.0, 0.0, 0.0);
glEnd();
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////
void CGLRenderer::SetLight()
{
float params1[4] = { 0.2, 0.2, 0.2, 1.0 };
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, params1);
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
glLightfv(GL_LIGHT0, GL_AMBIENT, params1);
float params2[4] = { 1.0, 1.0, 1.0, 1.0 };
glLightfv(GL_LIGHT0, GL_DIFFUSE, params2);
glLightfv(GL_LIGHT0, GL_SPECULAR, params2);
float params3[4] = { 4.0, 4.0, 4.0, 1.0 };
glLightfv(GL_LIGHT0, GL_POSITION, params3);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);
}
void CGLRenderer::SetSarcophagusTopMaterial()
{
float params1[4] = { 0.2, 0.2, 0.2, 1.0 };
glMaterialfv(GL_FRONT, GL_AMBIENT, params1);
float params2[4] = { 0.4, 0.0, 0.0, 1.0 };
glMaterialfv(GL_FRONT, GL_DIFFUSE, params2);
float params3[4] = { 0.0, 0.0, 0.0, 1.0 };
glMaterialfv(GL_FRONT, GL_SPECULAR, params3);
float params4[4] = { 0.0, 0.0, 0.0, 1.0 };
glMaterialfv(GL_FRONT, GL_EMISSION, params4);
}
void CGLRenderer::SetNormalMaterial()
{
float params1[4] = { 0.2, 0.2, 0.2, 1.0 };
glMaterialfv(GL_FRONT, GL_AMBIENT, params1);
float params2[4] = { 0.8, 0.8, 0.8, 1.0 };
glMaterialfv(GL_FRONT, GL_DIFFUSE, params2);
float params3[4] = { 0.0, 0.0, 0.0, 1.0 };
glMaterialfv(GL_FRONT, GL_SPECULAR, params3);
float params4[4] = { 0.0, 0.0, 0.0, 1.0 };
glMaterialfv(GL_FRONT, GL_EMISSION, params4);
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////
void CGLRenderer::PrepareTextures()
{
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glGenTextures(2, texIDs);
AUX_RGBImageRec* textureImage = NULL;
CString paths[2] = { CString("Egyptex.BMP"), CString("FE1031-SC.BMP") };
for (int i = 0; i < 2; i++)
{
textureImage = auxDIBImageLoad(paths[i]);
glBindTexture(GL_TEXTURE_2D, texIDs[i]);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, textureImage->sizeX, texture
Image->sizeY, GL_RGB, GL_UNSIGNED_BYTE, textureImage->data);
if (textureImage)
{
if (textureImage->data) free(textureImage->data);
free(textureImage);
}
}
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////
void CGLRenderer::OnKeyDown(UINT nChar)
{
if (nChar == 'Q')
{
angle += 5.0;
if (angle > 90.0) angle = 90.0;
}
if (nChar == 'W')
{
angle -= 5.0;
if (angle < 0.0) angle = 0.0;
}
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////
///////////////////////////////////
///////////////////////////////////
////////////////////////////////////
////////////////////////////////
///////////////////////////////////
///KOCKA SA TEXTURAMA
GLvoid glDrawCube()
// Draw A Cube
{
glBegin(GL_QUADS);
// Start Drawing Quads
// Front Face
glNormal3f( 0.0f, 0.0f, 1.0f);
// Normal Facing Forward
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f); // Bottom Le
ft Of The Texture and Quad
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);

ght Of The Texture and Quad
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
Of The Texture and Quad
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
// Back Face
glNormal3f( 0.0f, 0.0f,-1.0f);
// Normal Facing Away
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
// Top Face
// Normal Facing Up
// Bottom Face
glNormal3f( 0.0f,-1.0f, 0.0f);
// Normal Facing Down
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
// Right face
// Normal Facing Right
// Left Face
glNormal3f(-1.0f, 0.0f, 0.0f);
// Normal Facing Left
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
glEnd();
// Done Drawing Quads
}
// Bottom Ri
// Top Right
// Top Left
// Bottom Ri
// Top Right
// Top Left
// Bottom Le
// Top Left
// Bottom Le
// Bottom Ri
// Top Right
// Top Right
// Top Left
// Bottom Le
// Bottom Ri
// Bottom Ri
// Top Right
// Top Left
// Bottom Le
// Bottom Le
// Bottom Ri
// Top Right
// Top Left

Open GL

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Open GL

Uploaded by

Copyright:

Available Formats

///////CRTANJE FIGURA

void CGLRenderer::DrawPyramid(double size)

= 0; j < slices; j++)

glTexCoord2f(1.0 - j*ds, 0.5 + i*dt);

= 0; j < slices; j++)

glTexCoord2f(1.0 - j*ds, 0.5 - (i+1)*dt);

void CGLRenderer::DrawPillar(double x, double y, double z)

glNormal3f(1.0, 0.0, 0.0);

void CGLRenderer::DrawBox(double a, double b, double c)

glVertex3f(a2, b2, c2);

void CGLRenderer::DrawCylinder(double r, double h, int steps)

void CGLRenderer::DrawTrapezoid(float a, float b, float h, float H)

void CGLRenderer::DrawRing(float a, float b, float h, float H)

glRotatef(60.0, 0.0, 0.0, 1.0);

void CGLRenderer::COMPLEXDrawBox(double a, double b, double c)

for(j=0; j<c; j+=step)

for(double i=0; i< a; i+=step)

void CGLRenderer::SetLightModel()//postavljanje svetlosnog modela (globalno ambi

void CGLRenderer::SetWallMaterial()//popunjavanje materija za zid

void CGLRenderer::SetRedMetal()//popunjavanje materija za crveni metal \m/

void CGLRenderer::Reshape(CDC *pDC, int w, int h)

0.0, 1.0, 0.0);

int nPixelFormat = ChoosePixelFormat(pDC->m_hDC, &pfd);

void CGLRenderer::PrepareScene(CDC *pDC)

glClearColor(1.0, 1.0, 1.0, 0.0);

//ucitavanje texture zida (slicno kao sto)

int nPixelFormat = ChoosePixelFormat(pDC->m_hDC, &pfd);

glNormal3f(1.0, 0.0, 0.0);

glNormal3f(0.0, 1.0, 0.0);

glNormal3f(1.0, 0.0, 0.0);

glTexCoord2f(0.5, 0.0); glVertex3f(x, 0.0, 0.0);

glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);

You might also like

glTexCoord2f(1.0 - jds, 0.5 + idt);

glTexCoord2f(1.0 - jds, 0.5 - (i+1)dt);