Downloads

Java - Slides

2012-08-15T09:45:00.000-07:00

Class Room Slides

2012-01-07T09:22:00.000-08:00

Computer Graphics 2012

2012-01-04T08:07:00.000-08:00

Find Computer Graphics(CS375) Syllabus for 6th sem CSE 2012 Here
Find Computer Graphics CTA Distribution for 6th sem CSE 2012 Here

Academic Calendar 2012

2012-01-04T08:02:00.000-08:00

Download the Academic Calendar of even Semester Here

FS Theory Slides

2011-08-21T23:23:00.001-07:00

History of Hard Drives

2011-08-05T09:56:00.000-07:00

Chapter 1- History of Hard Drives

FS Google Book

2011-08-05T03:01:00.000-07:00

If you are having habit of reading books on ur computer.. Then dive into File Structures book below... Author : Michael J Folk, Bill Zoellick, Greg Riccardi.
Note : Some Pages might be missing

FS Semester Plans

2011-08-05T00:02:00.000-07:00

Find all the details regarding FS Semester Plans

FS Syllabus

CAT Syllabus

CTA Distribution

FS Academic Calendar

File Structures Syllabus

2011-07-31T10:52:00.000-07:00

Hi all,

For those who have taken FS as elective and don't know the syllabus!!! Click Here

Programs on Input & Interaction....

2011-03-21T10:11:00.000-07:00

Hi All,

We hope that CAT-1 exams were good.. :)

With this mail, we are attaching few OpenGL programs on Input Interaction.

Some of the programs have been commented for better understanding.

Go through these simple programs thoroughly and try to understand the flow.

This will help you to understand to program in OpenGL and also will help in understanding concepts related to input interaction.

Reply back to this mail in case of any queries.

Thanks,
Govind N. & Vishal K.

Program 1 :

#include<stdio.h>
#include<GL/glut.h>

int width=400, height=400; /* global varibles to hold width and height */

void myinit() /* function to initialize the attributes
and states of OpenGL */
{

/* attributes */
glClearColor(1.0, 1.0, 1.0, 1.0); /* white background */
glColor3f(1.0, 0.0, 0.0); /* draw in red */

/* set up viewing */
/* width x height window with origin lower left */
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, (GLdouble)width, 0.0, (GLdouble)height); /* setup viewing rectangle
equal to window width and height */
glMatrixMode(GL_MODELVIEW);
}

void drawPoint(int x, int y) /* user defined function to draw a point */
{

/* Draw the points using the values of x and y */
glPointSize(4.0); /* set the size of pixels to 4 */
glBegin(GL_POINTS);
glVertex2i(x, (height-y)); /* convert value of y from viewport co-ordinates
to world (screen) co-ordinates */
glEnd(); /* end the procedure */
glFlush(); /* flush contente of frame buffer to o/p device */

}

void display() /* called when window is opened */
{

glClear(GL_COLOR_BUFFER_BIT); /* clear the contents of color buffer */
glFlush(); /* flush contente of frame buffer to o/p device */
}

void myMouse(int btn, int state, int x, int y) /* called when mouse is clicked */
{

if(btn == GLUT_LEFT_BUTTON && state == GLUT_DOWN) /* will be true when left button is clicked
and button is held down */
{
drawPoint(x, y); /* call user-defined function to draw a point on window */
}
}

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

/* Standard GLUT initialization */
glutInit(&argc,argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB); /* default, not needed */
glutInitWindowSize(width,height); /* width x height pixel window */
glutInitWindowPosition(0,0); /* place window top left on display */
glutCreateWindow("Draw Points"); /* window title */
myinit(); /* set attributes */
glutDisplayFunc(display); /* display callback invoked when window opened */
glutMouseFunc(myMouse); /* mouse callback invoked when mouse clicked */

glutMainLoop(); /* enter event loop */
return 0;

}

Program 2 :

#include<stdio.h>
#include<GL/glut.h>

float x1[10], y1[10]; /* arrays to store co-ordinates of points that are drawn
on the winodw */
int width=400, height=400; /* global varibles to hold width and height */
int click=0; /* counter to keep track of no.of points drawn on the window */

void myinit() /* function to initialize the attributes
and states of OpenGL */
{

/* attributes */
glClearColor(1.0, 1.0, 1.0, 1.0); /* white background */
glColor3f(1.0, 0.0, 0.0); /* draw in red */

/* set up viewing */
/* width x height window with origin lower left */
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, (GLdouble)width, 0.0, (GLdouble)height); /* setup viewing rectangle
equal to window width and height */
glMatrixMode(GL_MODELVIEW);

}

void drawPoint(int x, int y) /* user defined function to draw a point */
{

/* Draw the points using the values of x and y */
glPointSize(4.0); /* set the size of pixels to 4 */
glBegin(GL_POINTS);
glVertex2i(x, (height-y)); /* convert value of y from viewport co-ordinates
to world (screen) co-ordinates */
glEnd(); /* end the procedure */
glFlush(); /* flush contente of frame buffer to o/p device */
}

void display() /* called when window is opened */
{

glClear(GL_COLOR_BUFFER_BIT); /* clear the contents of color buffer */
glFlush(); /* flush contente of frame buffer to o/p device */
}

void myMouse(int btn, int state, int x, int y) /* called when mouse is clicked */
{

int i;
if(btn == GLUT_LEFT_BUTTON && state == GLUT_DOWN) /* will be true when left button is clicked
and button is held down */
{
x1[click]=x; /* store each values of x in an array */
y1[click]=(height-y); /* sotre each values of y in an array */
click++; /* increment the counter */
drawPoint(x, y); /* draw the point on the window */
}
if(btn == GLUT_RIGHT_BUTTON && state == GLUT_DOWN) /* when right button is clicked */
{
glBegin(GL_LINE_LOOP);
for(i=0;i<click;i++) /* loop through all the points */
glVertex2i(x1[i], y1[i]); /* draw the lines between all the points */
glEnd();
glFlush();
}
if(btn == GLUT_MIDDLE_BUTTON && state == GLUT_DOWN) /* when middle button is clicked */
{
glutPostRedisplay(); /* calls display callback function, display,
which clears the screen */
click = 0; /* clear the counter */
}
}

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

/* Standard GLUT initialization */
glutInit(&argc,argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB); /* default, not needed */
glutInitWindowSize(width,height); /* width x height pixel window */
glutInitWindowPosition(0,0); /* place window top left on display */
glutCreateWindow("Draw Lines using Points"); /* window title */
glutDisplayFunc(display); /* display callback invoked when window opened */
myinit(); /* set attributes */
glutMouseFunc(myMouse); /* mouse callback invoked when mouse clicked */

glutMainLoop(); /* enter event loop */
return 0;

}

Program 3 :

#include<stdio.h>
#include<GL/glut.h>

float x1[10], y1[10]; /* arrays to store co-ordinates of points that are drawn
on the winodw */
int width=400, height=400; /* global varibles to hold width and height */
int click=0; /* counter to keep track of no.of points drawn on the window */

void myinit() /* function to initialize the attributes
and states of OpenGL */
{

/* attributes */
glClearColor(1.0, 1.0, 1.0, 1.0); /* white background */
glColor3f(1.0, 0.0, 0.0); /* draw in red */

/* set up viewing */
/* width x height window with origin lower left */
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, (GLdouble)width, 0.0, (GLdouble)height); /* setup viewing rectangle
equal to window width and height */
glMatrixMode(GL_MODELVIEW);

}

void drawPoint(int x, int y) /* user defined function to draw a point */
{

/* Draw the points using the values of x and y */
glPointSize(4.0); /* set the size of pixels to 4 */
glBegin(GL_POINTS);
glVertex2i(x, (height-y)); /* convert value of y from viewport co-ordinates
to world (screen) co-ordinates */
glEnd(); /* end the procedure */
glFlush(); /* flush contente of frame buffer to o/p device */
}

void display() /* called when window is opened */
{

glClear(GL_COLOR_BUFFER_BIT); /* clear the contents of color buffer */
glFlush(); /* flush contente of frame buffer to o/p device */
}

void myMouse(int btn, int state, int x, int y) /* called when mouse is clicked */
{

int i;
if(btn == GLUT_LEFT_BUTTON && state == GLUT_DOWN) /* will be true when left button is clicked
and button is held down */
{
x1[click]=x; /* store each values of x in an array */
y1[click]=(height-y); /* sotre each values of y in an array */
click++; /* increment the counter */
drawPoint(x, y); /* draw the point on the window */
}
if(btn == GLUT_RIGHT_BUTTON && state == GLUT_DOWN) /* when right button is clicked */
{
glBegin(GL_LINE_LOOP);
for(i=0;i<click;i++) /* loop through all the points */
glVertex2i(x1[i], y1[i]); /* draw the lines between all the points */
glEnd();
glFlush();
}
if(btn == GLUT_MIDDLE_BUTTON && state == GLUT_DOWN) /* when middle button is clicked */
{
glutPostRedisplay(); /* calls display callback function, display,
which clears the screen */
click = 0; /* clear the counter */
}
}

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

/* Standard GLUT initialization */
glutInit(&argc,argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB); /* default, not needed */
glutInitWindowSize(width,height); /* width x height pixel window */
glutInitWindowPosition(0,0); /* place window top left on display */
glutCreateWindow("Draw Lines using Points"); /* window title */
glutDisplayFunc(display); /* display callback invoked when window opened */
myinit(); /* set attributes */
glutMouseFunc(myMouse); /* mouse callback invoked when mouse clicked */

glutMainLoop(); /* enter event loop */
return 0;

}

Program 3:

#include<stdio.h>
#include<GL/glut.h>

float x1[10], y1[10]; /* arrays to store co-ordinates of points that are drawn
on the winodw */
int width=400, height=400; /* global varibles to hold width and height */
int click=0; /* counter to keep track of no.of points drawn on the window */

void myinit()
{

/* attributes */
glClearColor(1.0, 1.0, 1.0, 1.0); /* white background */
glColor3f(1.0, 0.0, 0.0); /* draw in red */

/* set up viewing */
/* width x height window with origin lower left */

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, (GLdouble)width, 0.0, (GLdouble)height);
glMatrixMode(GL_MODELVIEW);
}

void drawPoint(int x, int y)
{
glPointSize(4.0);
glBegin(GL_POINTS);
glVertex2i(x, (height-y));
glEnd();
glFlush();
}

void display()
{
glClear(GL_COLOR_BUFFER_BIT);

glFlush();
}

void myMouse(int btn, int state, int x, int y)
{
int i;
if(btn == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
{
x1[click]=x;
y1[click]=(height-y);
click++;
drawPoint(x, y);
}
if(btn == GLUT_RIGHT_BUTTON && state == GLUT_DOWN)
{
if(click<=10) /* display error if an attempt is made to draw
more than 10 points on to window */
{
glBegin(GL_LINE_LOOP);
for(i=0;i<click;i++)
{
glVertex2i(x1[i], y1[i]);
}
glEnd();
glFlush();
}
else
{
printf("Fatal Error! Points limit exceeded. Resetting the count\n");
glutPostRedisplay();
click=0;
}
}
if(btn == GLUT_MIDDLE_BUTTON && state == GLUT_DOWN)
{
glutPostRedisplay();
click = 0;
}
}

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

/* Standard GLUT initialization */
glutInit(&argc,argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB); /* default, not needed */
glutInitWindowSize(width,height); /* width x height pixel window */
glutInitWindowPosition(0,0); /* place window top left on display */
glutCreateWindow("Rubberbanding"); /* window title */
glutDisplayFunc(display); /* display callback invoked when window opened */
myinit(); /* set attributes */
glutMouseFunc(myMouse); /* mouse callback invoked when mouse clicked */

glutMainLoop(); /* enter event loop */
return 0;

}

Program 4:

#include<stdio.h>
#include<GL/glut.h>

float x1[10], y1[10];
int first = 0;
int width=400, height=400;
int click=0;

void myinit()
{

/* attributes */

glClearColor(1.0, 1.0, 1.0, 1.0); /* white background */
glColor3f(1.0, 0.0, 0.0); /* draw in red */

/* set up viewing */
/* 500 x 500 window with origin lower left */

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, (GLdouble)width, 0.0, (GLdouble)height);
glMatrixMode(GL_MODELVIEW);
}

void drawPoint(int x, int y)
{
//glPointSize(4.0);
glBegin(GL_POINTS);
glVertex2i(x, (height-y));
glEnd();
glFlush();
}

void display()
{
glClear(GL_COLOR_BUFFER_BIT);

glFlush();
}

void myMouse(int btn, int state, int x, int y)
{
int i;
if(btn == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
{
drawPoint(x, y);
}
if(btn == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
{
drawPoint(x, y);
}

}

void move(int x, int y)
{
drawPoint(x, y);
}

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

/* Standard GLUT initialization */

glutInit(&argc,argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB); /* default, not needed */
glutInitWindowSize(width,height); /* 500 x 500 pixel window */
glutInitWindowPosition(0,0); /* place window top left on display */
glutCreateWindow("Rubberbanding"); /* window title */
glutDisplayFunc(display); /* display callback invoked when window opened */

myinit(); /* set attributes */
glutMouseFunc(myMouse);
glutMotionFunc(move);
glutMainLoop(); /* enter event loop */

return 0;

}

GLUT Motion Func Callback....

2011-03-07T01:01:00.003-08:00

Hi All,

PF the code below that demonstrates the use of glutMotionFunc() callback function.

Analyze this code and mail back to us for any queries.

You can post your queries here.

Thanks,

Govind N. & Vishal K.

#include <GL/glut.h>
#include <stdlib.h>

GLsizei wh = 500, ww = 500; /* initial window size */
GLfloat size = 10.0; /* half side length of square */

void drawSquare(int x, int y)
{

   y=wh-y;
   glColor3ub( (char) rand()%256, (char) rand()%256, (char) rand()%256);
   glBegin(GL_POLYGON);
    glVertex2f(x+size, y+size);
      glVertex2f(x-size, y+size);
    glVertex2f(x-size, y-size);
     glVertex2f(x+size, y-size);
   glEnd();
   glFlush();
}

/* rehaping routine called whenever window is resized
or moved */

void myReshape(GLsizei w, GLsizei h)
{

/* adjust clipping box */

   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   glOrtho(0.0, (GLdouble)w, 0.0, (GLdouble)h, -1.0, 1.0);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();

/* adjust viewport and clear */

    glViewport(0,0,w,h);
    glClearColor (0.0, 0.0, 0.0, 1.0);
   glClear(GL_COLOR_BUFFER_BIT);
   glFlush();

/* set global size for use by drawing routine */

ww = w;
wh = h;
}

void myinit(void)
{

glViewport(0,0,ww,wh);

/* Pick 2D clipping window to match size of screen window
This choice avoids having to scale object coordinates
each time window is resized */

   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   glOrtho(0.0, (GLdouble) ww , 0.0, (GLdouble) wh , -1.0, 1.0);

/* set clear color to black and clear window */

   glClearColor (0.0, 0.0, 0.0, 1.0);
    glClear(GL_COLOR_BUFFER_BIT);
    glFlush();

/* callback routine for reshape event */

glutReshapeFunc(myReshape);

}

void mouse(int btn, int state, int x, int y)
{
if(btn==GLUT_RIGHT_BUTTON && state==GLUT_DOWN) exit(0);
}

/* display callback required by GLUT 3.0 */

void display(void)
{}

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

   glutInit(&argc,argv);
    glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
    glutCreateWindow("square");
   myinit ();
   glutReshapeFunc (myReshape);
   glutMouseFunc (mouse);
   glutMotionFunc(drawSquare);
    glutDisplayFunc(display);

glutMainLoop();

}

CG Event Handling Forum.......

2011-03-03T08:47:00.000-08:00

Hi All,

PFA the code that demonstrates event handling mechanism in OpenGL.

Analyze the attached program thoroughly and get the answers for the below questions:

When the program is run, initially why a window with white background is displayed?

When middle button of the mouse is clicked, why nothing is drawn on the window?

When left and right buttons are clicked, why circle and Sierpinski Gasket are drawn at different positions on the window?

Is it possible to modify the code such that both circle and Sierpinski Gasket are drawn from the point where the mouse is clicked on the window?

When window is maximized, why nothing is drawn on the window?

What modifications in the code has to be made if the aspect ratio of the object drawn should remain the same when the window is resized/maximized?

What modifications in the code has to be made so that the program should be terminated if the middle button of the mouse or 'q' / 'Q' key is pressed from the keyboard?

Thanks,

Govind N. & Vishal K

HAVE YOUR SAY IN THIS DISCUSSION FORUM......

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

void gasket();

void myinit()
{
   glClearColor(1.0, 1.0, 1.0, 1.0); /* white background */
   glColor3f(1.0, 0.0, 0.0); /* draw in red */
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   gluOrtho2D(-10.0, 10.0, -10.0, 10.0);
   glMatrixMode(GL_MODELVIEW);
}

void draw()
{
   int r=10;
   GLfloat theta;

   glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_POLYGON);
for(theta=0; theta<=360; theta+=0.01)
   {
   glVertex2f(5*sin(theta*3.142/180), 5*cos(theta*3.142/180));
   }
glEnd();
   glFlush();
}

void myMouse(int button, int state, int x,int y)
{
   if(button==GLUT_LEFT_BUTTON && state==GLUT_DOWN)
   {
   draw();
   }
   else if(button==GLUT_RIGHT_BUTTON && state==GLUT_DOWN)
   {
   gasket();
   }
}

void gasket()
{
   GLfloat v[3][2] = {{1.0, 1.0}, {6.0, 1.0}, {3.5, 5.5}}; // Assign co-ordinates to draw 3 points for triangle
   GLfloat p[2] = {2.5, 2.5}; // Take an initial point
   int j, i;

   glClear(GL_COLOR_BUFFER_BIT);
   glBegin(GL_POINTS);
   for(i=0; i<50000; i++)
   {
   j=rand()%3; // Select a vertex randomly in each iteration
   p[0]=(p[0] + v[j][0])/2.0; // Compute the mid-point between P and selected vertex
   p[1]=(p[1] + v[j][1])/2.0; // Compute the mid-point between P and selected vertex

   glVertex2fv(p); // Display this point on the screen
   }
   glEnd();
   glFlush();
}

void display()
{
   glClear(GL_COLOR_BUFFER_BIT);
   glFlush();
}

void myKey(unsigned char key, int x1, int y1)
{
   if(key=='c' || key=='C')
   {
   draw();
   }
   else if(key=='g' || key=='G')
   {
   gasket();
   }
}

int main(int argc, char** argv)
{
   glutInit(&argc,argv);
   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB); /* default, not needed */
   glutInitWindowSize(500,500); /* 500 x 500 pixel window */
   glutInitWindowPosition(0,0); /* place window top left on display */
   glutCreateWindow("Mouse and Key");
   glutDisplayFunc(display);
   glutMouseFunc(myMouse); /* display callback invoked when window opened */
   glutKeyboardFunc(myKey);
   myinit(); /* set attributes */
   glutMainLoop(); /* enter event loop */
   return 0;
}

Downloads

2011-02-24T09:53:00.000-08:00

Click Here to Download the PPT of Computer Graphics by Edward Angel.

Download the OpenGL Manual Here