Scribd
Upload
55 views7 pages

#Include #Include #Include #Include

This document contains C code for rendering a scene with mirrors using OpenGL. It defines functions for initializing graphics settings, drawing various scene elements like walls, spheres and cones, handling user input, and implementing reflection through mirrors using stencil buffering and matrix transformations. The main function sets up the window and display callback and creates menus for toggling lights and rendering modes. It then enters the main loop to continuously redraw the reflective scene.

Uploaded by

savijeth
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
55 views7 pages

#Include #Include #Include #Include

This document contains C code for rendering a scene with mirrors using OpenGL. It defines functions for initializing graphics settings, drawing various scene elements like walls, spheres and cones, handling user input, and implementing reflection through mirrors using stencil buffering and matrix transformations. The main function sets up the window and display callback and creates menus for toggling lights and rendering modes. It then enters the main loop to continuously redraw the reflective scene.

Uploaded by

savijeth
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 7

#include

#include
#include
#include

<math.h>
<stdio.h>
<stdlib.h>
<GL/glut.h>

GLUquadricObj *cone, *base, *qsphere;


#define M_PI 3.142
#define trunc(x) ((double)((int)(x)))
float specReflection[] = { 0.8f, 0.8f, 0.8f,1 };
float mcolor[] = { 1, 0, 0, 1};
int draw_passes = 4;
int headsUp = 0;
int sub_menu1,sub_menu2;
typedef struct {
GLfloat verts[4][3];
GLfloat scale[3];
GLfloat trans[3];
} Mirror;
Mirror mirrors[] = {
{{{-1., -.75, -.75}, {-1., .75, -.75}, {-1., .75, .75}, {-1, -.75, .75}},
{-1, 1, 1}, {2, 0, 0}},
{{{1., -.75, .75}, {1., .75, .75}, {1., .75, -.75}, {1., -.75, -.75}},
{-1, 1, 1}, {-2, 0, 0}}
};
int nMirrors =2 ;
void init(void)
{
static GLfloat lightpos[] = {.6, .75, 1.5, 1};
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mcolor);
glMaterialfv(GL_FRONT, GL_SPECULAR, specReflection);
glMateriali(GL_FRONT, GL_SHININESS, 110);
glEnable(GL_LIGHT0);
glEnable(GL_CULL_FACE);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);

cone = gluNewQuadric();
qsphere = gluNewQuadric();

void make_viewpoint(void)

if (headsUp) {
float width = (1 + 2*(draw_passes/nMirrors)) * 1.25;
float height = (width / tan((30./360.) * (2.*M_PI))) + 1;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(75, 1, height - 3, height + 3);
gluLookAt(0, height, 0,
0, 0, 0,
0, 0, 1);
}
else {
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60, 1, .01, 4 + 2*(draw_passes / nMirrors));
gluLookAt(-2, 0, .75,
0, 0, 0,
0, 1, 0);
}
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();

}
void reshape(GLsizei w, GLsizei h)
{
glViewport(0, 0, w, h);
make_viewpoint();
}
void draw_room(void)
{
static GLfloat wall_mat[] = {1,1,1,1};
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, wall_mat);
glBegin(GL_QUADS);
glNormal3f(0, 1, 0);
glVertex3f(-1, -1, 1);
glVertex3f(1, -1, 1);
glVertex3f(1, -1, -1);
glVertex3f(-1, -1, -1);
glNormal3f(0, -1, 0);
glVertex3f(-1, 1, -1);
glVertex3f(1, 1, -1);
glVertex3f(1, 1, 1);
glVertex3f(-1, 1, 1);
glNormal3f(1, 0, 0);
glVertex3f(-1, -1, -1);
glVertex3f(-1, 1, -1);
glVertex3f(-1, 1, 1);
glVertex3f(-1, -1, 1);
glNormal3f(-1, 0, 0);

glVertex3f(1,
glVertex3f(1,
glVertex3f(1,
glVertex3f(1,

-1, 1);
1, 1);
1, -1);
-1, -1);

glNormal3f(0, 0, 1);
glVertex3f(-1, -1, -1);
glVertex3f(1, -1, -1);
glVertex3f(1, 1, -1);
glVertex3f(-1, 1, -1);
glNormal3f(0, 0, -1);
glVertex3f(-1, 1, 1);
glVertex3f(1, 1, 1);
glVertex3f(1, -1, 1);
glVertex3f(-1, -1, 1);
glEnd();
}
void draw_cone(void)
{
static GLfloat cone_mat[] = {0.f, .5f, 1.f, 1.f};
glPushMatrix();
glTranslatef(0, -1, 0);
glRotatef(-90, 1, 0, 0);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, cone_mat);
gluCylinder(cone, 0.3, 0, 1.25, 20, 1);
}

glPopMatrix();

void draw_sphere(GLdouble secs)


{
static GLfloat sphere_mat[] = {1.f, .5f, 0.f, 1.f};
GLfloat angle;
secs = secs - 10.*trunc(secs / 10.);
angle = (secs/10.) * (360.);
glPushMatrix();
glTranslatef(0, -.3, 0);
glRotatef(angle, 0, 1, 0);
glTranslatef(.6, 0, 0);

glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, sphere_mat);


gluSphere(qsphere, .3, 60, 60);
glPopMatrix();

GLdouble get_secs(void)
{
return glutGet(GLUT_ELAPSED_TIME) / 1000.0;
}

void draw_mirror(Mirror *m)


{
glBegin(GL_QUADS);
glVertex3fv(m->verts[0]);
glVertex3fv(m->verts[1]);
glVertex3fv(m->verts[2]);
glVertex3fv(m->verts[3]);
glEnd();
}
GLenum reflect_through_mirror(Mirror *m, GLenum cullFace)
{
GLenum newCullFace = ((cullFace == GL_FRONT) ? GL_BACK : GL_FRONT);
glMatrixMode(GL_PROJECTION);
glScalef(m->scale[0], m->scale[1], m->scale[2]);
glTranslatef(m->trans[0], m->trans[1], m->trans[2]);
glMatrixMode(GL_MODELVIEW);
glCullFace(newCullFace);
return newCullFace;
}
void undo_reflect_through_mirror(Mirror *m, GLenum cullFace)
{
glMatrixMode(GL_PROJECTION);
glTranslatef(-m->trans[0], -m->trans[1], -m->trans[2]);
glScalef(1./m->scale[0], 1./m->scale[1], 1./m->scale[2]);
glMatrixMode(GL_MODELVIEW);
glCullFace(cullFace);
}
void draw_scene(GLdouble secs, int passes, GLenum cullFace,
GLuint stencilVal, GLuint mirror)
{
GLenum newCullFace;
int passesPerMirror, passesPerMirrorRem;
unsigned int curMirror, drawMirrors;
int i;
passes--;
glStencilFunc(GL_EQUAL, stencilVal, 0xffffffff);
draw_sphere(secs);
draw_cone();
if (mirror != 0xffffffff) {
passesPerMirror = passes / (nMirrors - 1);
passesPerMirrorRem = passes % (nMirrors - 1);
if (passes > nMirrors - 1) drawMirrors = nMirrors - 1;
else drawMirrors = passes;
}
else {
passesPerMirror = passes / nMirrors;

passesPerMirrorRem = passes % nMirrors;


if (passes > nMirrors) drawMirrors = nMirrors;
else drawMirrors = passes;
}
for (i = 0; drawMirrors > 0; i++) {
curMirror = i % nMirrors;
if (curMirror == mirror) continue;
drawMirrors--;
glColorMask(0, 0, 0, 0);
glDepthMask(0);
glStencilOp(GL_KEEP, GL_KEEP, GL_INCR);
draw_mirror(&mirrors[curMirror]);
glColorMask(1, 1, 1, 1);
glDepthMask(1);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
newCullFace = reflect_through_mirror(&mirrors[curMirror], cullFace);
if (passesPerMirrorRem) {
draw_scene(secs, passesPerMirror + 1, newCullFace, stencilVal + 1,
curMirror);
passesPerMirrorRem--;
} else {
draw_scene(secs, passesPerMirror, newCullFace, stencilVal + 1,
curMirror);
}
undo_reflect_through_mirror(&mirrors[curMirror], cullFace);
glStencilFunc(GL_EQUAL, stencilVal, 0xffffffff);
}
draw_room();
}
void draw(void)
{
GLenum err;
GLfloat secs = get_secs();
glDisable(GL_STENCIL_TEST);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
if (!headsUp) glEnable(GL_STENCIL_TEST);
draw_scene(secs, draw_passes, GL_BACK, 0, (unsigned)-1);
glDisable(GL_STENCIL_TEST);
if (headsUp) {
glDisable(GL_LIGHTING);
glBegin(GL_QUADS);
glColor3f(1, 0, 0);
glVertex3f(-1, -.95, 1);
glVertex3f(1, -.95, 1);
glVertex3f(1, -.95, -1);
glVertex3f(-1, -.95, -1);
glEnd();
glEnable(GL_LIGHTING);

}
err = glGetError();
if (err != GL_NO_ERROR) printf("Error: %s\n", gluErrorString(err));

glutSwapBuffers();

void key(unsigned char key, int x, int y)


{
switch(key) {
case '+':
draw_passes+=2;
printf(" Passes = %d\n", draw_passes);
make_viewpoint();
break;
case '-':
draw_passes-=2;
if (draw_passes < 1) draw_passes = 1;
printf(" Passes = %d\n", draw_passes);
make_viewpoint();
break;
case 'v':
headsUp = 1;
make_viewpoint();
break;
case 'b':
headsUp=0;
make_viewpoint();
break;
case 27:
exit(0);
}
}
void MIRRORS(int id)
{
switch(id)
{
case 1: exit(0);
break;
default :break;
}
glutPostRedisplay();
}
void lightMenu(int id)
{
switch(id)
{
case 4: glEnable(GL_LIGHT0);
break;
case 5:glDisable(GL_LIGHT0);
break;
default :break;
}
glutPostRedisplay();
}
void dispMenu(int id)

switch(id)
{
case 2: glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
break;
case 3: glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
break;
default :break;
}
glutPostRedisplay();

int main(int argc, char *argv[])


{
glutInit(&argc, argv);
glutInitWindowSize(500, 500);
glutInitWindowPosition(30,30);
glutInitDisplayString("samples stencil>=3 rgb double depth");
glutCreateWindow(" MIRRORS ");
glutDisplayFunc(draw);
glutIdleFunc(draw);
glutKeyboardFunc(key);
glutReshapeFunc(reshape);
init();
sub_menu1=glutCreateMenu(lightMenu);
glutAddMenuEntry("On",4);
glutAddMenuEntry("Off",5);
sub_menu2=glutCreateMenu(dispMenu);
glutAddMenuEntry("Wire Frame",2);
glutAddMenuEntry("Polygon Frame",3);
glutCreateMenu(MIRRORS);
glutAddSubMenu("Display Mode",sub_menu2);
glutAddSubMenu("Light0",sub_menu1);
glutAddMenuEntry("Quit",1);
glutAttachMenu(GLUT_RIGHT_BUTTON);

glutMainLoop();
return 0;

You might also like