PROGRAM 1:-
**********Implement Brenham's line drawing algorithm for all types of slope.***********
#include<GL/glut.h>
#include<stdio.h>
int x1, y1, x2, y2;
void draw_pixel(int x, int y)
glColor3f(1.0,0.0,0.0);
glBegin(GL_POINTS);
glVertex2i(x, y);
glEnd();
void bresenhams_line_draw(int x1, int y1, int x2, int y2)
float dx = x2 - x1;
float dy = y2 - y1;
float m = dy/dx;
if(m < 1)
int decision_parameter = 2*dy - dx;
int x = x1; // initial x
int y = y1; // initial y
if(dx < 0) // decide the first point and second point
x = x2;
y = y2;
x2 = x1;
draw_pixel(x, y); // plot a point
while(x < x2) // from 1st point to 2nd point
if(decision_parameter >= 0)
x = x+1;
y = y+1;
decision_parameter=decision_parameter + 2*dy - 2*dx * (y+1 - y);
else
x = x+1;
y = y;
decision_parameter = decision_parameter + 2*dy - 2*dx * (y- y);
draw_pixel(x, y);
}
else if(m > 1)
int decision_parameter = 2*dx - dy;
int x = x1; // initial x
int y = y1; // initial y
if(dy < 0)
x = x2;
y = y2;
y2 = y1;
draw_pixel(x, y);
while(y < y2)
if(decision_parameter >= 0)
x = x+1;
y = y+1;
decision_parameter=decision_parameter + 2*dx - 2*dy * (x+1 - x);
else
y = y+1;
x = x;
decision_parameter = decision_parameter + 2*dx - 2*dy * (x- x);
}
draw_pixel(x, y);
else if (m == 1)
int x = x1;
int y = y1;
draw_pixel(x, y);
while(x < x2)
x = x+1;
y = y+1;
draw_pixel(x, y);
void init()
glClearColor(1,1,1,1);
gluOrtho2D(0.0, 500.0, 0.0, 500.0); // left ->0, right ->500, bottom ->0, top ->500
}
void display()
glClear(GL_COLOR_BUFFER_BIT);
bresenhams_line_draw(x1, y1, x2, y2);
glFlush();
int main(int argc, char **argv)
printf( "Enter Start Points (x1,y1)\n");
scanf("%d %d", &x1, &y1); // 1st point from user
printf( "Enter End Points (x2,y2)\n");
scanf("%d %d", &x2, &y2); // 2nd point from user
glutInit(&argc, argv); // initialize graphics system
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); // single buffered mode with RGB colour variants
glutInitWindowSize(500, 500); // 500 by 500 window size
glutInitWindowPosition(220, 200); // where do you wanna see your window
glutCreateWindow("Bresenham's Line Drawing - FVBIE"); // the title of your window
init(); // initialize the canvas
glutDisplayFunc(display); // call display function
glutMainLoop(); // run forever
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
PROGRAM 2:-
#include<GL/glut.h>
#include<stdio.h>
int x,y;
int where_to_rotate=0; // don't rotate initially
float rotate_angle=0; // initial angle
float translate_x=0,translate_y=0; // initial translation
void draw_pixel(float x1, float y1)
glPointSize(5);
glBegin(GL_POINTS);
glVertex2f(x1,y1); // plot a single point
glEnd();
void triangle(int x, int y)
glColor3f(1,0,0);
glBegin(GL_POLYGON); // drawing a Triangle
glVertex2f(x,y);
glVertex2f(x+400,y+300);
glVertex2f(x+300,y+0);
glEnd();
void display()
glClear(GL_COLOR_BUFFER_BIT);
glLoadIdentity();
glColor3f(1,1,1); // mark origin point as white dot
draw_pixel(0,0); // plot origin - white colour
if (where_to_rotate == 1) //Rotate Around origin
translate_x = 0; // no translation for rotation around origin
translate_y = 0;
rotate_angle += 1; // the amount of rotation angle
if (where_to_rotate == 2) //Rotate Around Fixed Point
translate_x = x; // SET the translation to wherever the customer says
translate_y = y;
rotate_angle += 1; // the amount of rotation angle
glColor3f(0,0,1); // mark the customer coordinate as blue dot
draw_pixel(x,y); // plot the customer coordinate - blue colour
glTranslatef(translate_x, translate_y, 0); // ACTUAL translation +ve
glRotatef(rotate_angle, 0, 0, 1); // rotate
glTranslatef(-translate_x, -translate_y, 0); // ACTUAL translation -ve
triangle(translate_x,translate_y); // what to rotate? - TRIANGLE
glutPostRedisplay(); // call display function again and again
glutSwapBuffers(); // show the output
void init()
glClearColor(0,0,0,1); //setting to black
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(-800, 800, -800, 800);
glMatrixMode(GL_MODELVIEW);
void rotateMenu (int option)
{
if(option==1)
where_to_rotate=1; // rotate around origin
if(option==2)
where_to_rotate=2; // rotate around customer's coordinates
if(option==3)
where_to_rotate=3; // stop rotation
int main(int argc, char **argv)
printf( "Enter Fixed Points (x,y) for Rotation: \n");
scanf("%d %d", &x, &y); // getting the user's coordinates to rotate
glutInit(&argc, argv); // initialize the graphics system
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB); // SINGLE also works
glutInitWindowSize(800, 800); // 800 by 800 size..you can change it
glutInitWindowPosition(0, 0); // where do you wanna see your window
glutCreateWindow("Create and Rotate Triangle"); // title
init(); // initialize the canvas
glutDisplayFunc(display); // call display function
glutCreateMenu(rotateMenu); // menu items
glutAddMenuEntry("Rotate around ORIGIN",1);
glutAddMenuEntry("Rotate around FIXED POINT",2);
glutAddMenuEntry("Stop Rotation",3);
glutAttachMenu(GLUT_RIGHT_BUTTON);
glutMainLoop(); // run forever
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
PROGRAM 3:-
#include<stdlib.h>
#include<GL/glut.h>
GLfloat vertices[]= {-1, -1, -1,
1, -1, -1,
1, 1, -1,
-1, 1, -1,
-1, -1, 1,
1, -1, 1,
1, 1, 1,
-1, 1, 1
};
GLfloat colors[]= {0, 0, 0,
1, 0, 0,
1, 1, 0,
0, 1, 0,
0, 0, 1,
1, 0, 1,
1, 1, 1,
0, 1, 1
};
GLubyte cubeIndices[]= {0, 3, 2, 1,
2, 3, 7, 6,
0, 4, 7, 3,
1, 2, 6, 5,
4, 5, 6, 7,
0, 1, 5, 4
};
static GLfloat theta[]= {0,0,0};
static GLint axis=2;
void display(void)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glRotatef(theta[0], 1, 0, 0);
glRotatef(theta[1], 0, 1, 0);
glRotatef(theta[2], 0, 0, 1);
glDrawElements(GL_QUADS,24,GL_UNSIGNED_BYTE,cubeIndices);
glutSwapBuffers();
void spinCube()
theta[axis] += 2;
if(theta[axis] > 360)
theta[axis] -= 360;
glutPostRedisplay();
void mouse(int btn, int state, int x, int y)
if(btn==GLUT_LEFT_BUTTON && state==GLUT_DOWN)
axis=0;
if(btn==GLUT_MIDDLE_BUTTON && state==GLUT_DOWN)
axis=1;
if(btn==GLUT_RIGHT_BUTTON && state==GLUT_DOWN)
axis=2;
void myReshape(int w, int h)
glViewport(0,0,w,h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if(w<=h)
glOrtho(-2, 2, -2*(GLfloat)h/(GLfloat)w, 2*(GLfloat)h/(GLfloat)w, -10, 10);
else
glOrtho(-2*(GLfloat)w/(GLfloat)h, 2*(GLfloat)w/(GLfloat)h, -2, 2, -10, 10);
glMatrixMode(GL_MODELVIEW);
int main(int argc, char **argv)
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH);
glutInitWindowSize(500, 500);
glutCreateWindow("Spin a color cube");
glutReshapeFunc(myReshape);
glutDisplayFunc(display);
glutIdleFunc(spinCube);
glutMouseFunc(mouse);
glEnable(GL_DEPTH_TEST);
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, vertices);
glColorPointer(3, GL_FLOAT, 0, colors);
glColor3f(1, 1, 1);
glutMainLoop();
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::PROGRAM 4:-
#include <stdlib.h>
#include <GL/glut.h>
GLfloat vertices[][3] = { {-1,-1,-1},
{1,-1,-1},
{1,1,-1},
{-1,1,-1},
{-1,-1,1},
{1,-1,1},
{1,1,1},
{-1,1,1}
};
GLfloat colors[][3] = { {1,0,0},
{1,1,0},
{0,1,0},
{0,0,1},
{1,0,1},
{1,1,1},
{0,1,1},
{0.5,0.5,0.5}
};
GLfloat theta[] = {0.0,0.0,0.0};
GLint axis = 2;
GLdouble viewer[]= {0.0, 0.0, 5.0}; // initial viewer location //
void polygon(int a, int b, int c, int d)
glBegin(GL_POLYGON);
glColor3fv(colors[a]);
glVertex3fv(vertices[a]);
glColor3fv(colors[b]);
glVertex3fv(vertices[b]);
glColor3fv(colors[c]);
glVertex3fv(vertices[c]);
glColor3fv(colors[d]);
glVertex3fv(vertices[d]);
glEnd();
void colorcube(void)
polygon(0,3,2,1);
polygon(0,4,7,3);
polygon(5,4,0,1);
polygon(2,3,7,6);
polygon(1,2,6,5);
polygon(4,5,6,7);
void display(void)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
gluLookAt(viewer[0],viewer[1],viewer[2], 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glRotatef(theta[0], 1.0, 0.0, 0.0);
glRotatef(theta[1], 0.0, 1.0, 0.0);
glRotatef(theta[2], 0.0, 0.0, 1.0);
colorcube();
glFlush();
glutSwapBuffers();
void mouse(int btn, int state, int x, int y)
if(btn==GLUT_LEFT_BUTTON && state == GLUT_DOWN) axis = 0;
if(btn==GLUT_MIDDLE_BUTTON && state == GLUT_DOWN) axis = 1;
if(btn==GLUT_RIGHT_BUTTON && state == GLUT_DOWN) axis = 2;
theta[axis] += 2.0;
if( theta[axis] > 360.0 ) theta[axis] -= 360.0;
display();
void keys(unsigned char key, int x, int y)
if(key == 'x') viewer[0]-= 1.0;
if(key == 'X') viewer[0]+= 1.0;
if(key == 'y') viewer[1]-= 1.0;
if(key == 'Y') viewer[1]+= 1.0;
if(key == 'z') viewer[2]-= 1.0;
if(key == 'Z') viewer[2]+= 1.0;
display();
void myReshape(int w, int h)
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if(w<=h)
glFrustum(-2.0, 2.0, -2.0 * (GLfloat) h/ (GLfloat) w, 2.0* (GLfloat) h / (GLfloat) w,2.0, 20.0);
else
glFrustum(-2.0, 2.0, -2.0 * (GLfloat) w/ (GLfloat) h, 2.0* (GLfloat) w / (GLfloat) h, 2.0, 20.0);
glMatrixMode(GL_MODELVIEW);
int main(int argc, char **argv)
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(500, 500);
glutCreateWindow("Colorcube Viewer");
glutReshapeFunc(myReshape);
glutDisplayFunc(display);
glutMouseFunc(mouse);
glutKeyboardFunc(keys);
glEnable(GL_DEPTH_TEST);
glutMainLoop();
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
PROGRAM 5:-
#include <stdio.h>
#include <GL/glut.h>
double xmin = 50, ymin = 50, xmax = 100, ymax = 100; //window coordinates
double xvmin = 200, yvmin = 200, xvmax = 300, yvmax = 300; //viewport coordinates
const int LEFT = 1; // code words for LEFT, RIGHT, BOTTOM &TOP.
const int RIGHT = 2;
const int BOTTOM = 4;
const int TOP = 8;
int ComputeOutCode (double x, double y)
int code = 0;
if (y > ymax) //above the clip window
code |= TOP;
else if (y < ymin) //below the clip window
code |= BOTTOM;
if (x > xmax) //to the right of clip window
code |= RIGHT;
else if (x < xmin) //to the left of clip window
code |= LEFT;
return code;
void CohenSutherland(double x0, double y0,double x1, double y1)
int outcode0, outcode1, outcodeOut;
bool accept = false, done = false;
outcode0 = ComputeOutCode (x0, y0); //calculate the region of 1st point
outcode1 = ComputeOutCode (x1, y1); //calculate the region of 2nd point
do
if (!(outcode0 | outcode1))
accept = true;
done = true;
else if (outcode0 & outcode1)
done = true;
else
double x, y;
double m = (y1 - y0)/(x1 - x0);
outcodeOut = outcode0? outcode0: outcode1;
if (outcodeOut & TOP)
x = x0 + (1/m) * (ymax - y0);
y = ymax;
else if (outcodeOut & BOTTOM)
x = x0 + (1/m) * (ymin - y0);
y = ymin;
else if (outcodeOut & RIGHT)
y = y0 + m * (xmax - x0);
x = xmax;
else
y = y0 + m * (xmin - x0);
x = xmin;
/* Intersection calculations over */
if (outcodeOut == outcode0)
x0 = x;
y0 = y;
outcode0 = ComputeOutCode (x0, y0);
else
x1 = x;
y1 = y;
outcode1 = ComputeOutCode (x1, y1);
while (!done);
if (accept)
double sx = (xvmax - xvmin) / (xmax - xmin);
double sy = (yvmax - yvmin) / (ymax - ymin);
double vx0 = xvmin + (x0 - xmin) * sx;
double vy0 = yvmin + (y0 - ymin) * sy;
double vx1 = xvmin + (x1 - xmin) * sx;
double vy1 = yvmin + (y1 - ymin) * sy;
glBegin(GL_LINE_LOOP);
glVertex2f(xvmin, yvmin);
glVertex2f(xvmax, yvmin);
glVertex2f(xvmax, yvmax);
glVertex2f(xvmin, yvmax);
glEnd();
glBegin(GL_LINES);
glVertex2d (vx0, vy0);
glVertex2d (vx1, vy1);
glEnd();
void display()
double x0 = 60, y0 = 20, x1 = 80, y1 = 120;
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1, 1, 1);//white
glBegin(GL_LINES);
glVertex2d (x0, y0);
glVertex2d (x1, y1);
glEnd();
glBegin(GL_LINE_LOOP);
glVertex2f(xmin, ymin);
glVertex2f(xmax, ymin);
glVertex2f(xmax, ymax);
glVertex2f(xmin, ymax);
glEnd();
CohenSutherland(x0, y0, x1, y1);
glFlush();
void myinit()
glClearColor(0, 0, 0, 1);//black
gluOrtho2D(0, 500, 0, 500);
int main(int argc, char **argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(500, 500);
glutInitWindowPosition(0, 0);
glutCreateWindow("Cohen Sutherland Line Clipping Algorithm");
myinit();
glutDisplayFunc(display);
glutMainLoop();
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
PROGRAM 6:-
#include<GL/glut.h>
void teapot(GLfloat x,GLfloat y,GLfloat z)
glPushMatrix();
glTranslatef(x, y, z);
glutSolidTeapot(0.1);
glPopMatrix();
void tableTop(GLfloat x, GLfloat y, GLfloat z)
{
glPushMatrix();
glTranslatef(x, y, z);
glScalef(0.6, 0.02, 0.5);
glutSolidCube(1);
glPopMatrix();
void tableLeg(GLfloat x, GLfloat y, GLfloat z)
glPushMatrix();
glTranslatef(x, y, z);
glScalef(0.02, 0.3, 0.02);
glutSolidCube(1);
glPopMatrix();
void wall(GLfloat x, GLfloat y, GLfloat z)
glPushMatrix();
glTranslatef(x, y, z);
glScalef(1, 1, 0.02);
glutSolidCube(1);
glPopMatrix();
void light()
{
GLfloat mat_ambient[] = {1, 1, 1, 1};
GLfloat mat_diffuse[] = {0.5, 0.5, 0.5, 1};
GLfloat mat_specular[] = {1, 1, 1, 1};
GLfloat mat_shininess[] = {50.0f};
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
GLfloat light_position[] = {2, 6, 3, 1};
GLfloat light_intensity[] = {0.7, 0.7, 0.7, 1};
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_intensity);
void display()
GLfloat teapotP = -0.07, tabletopP = -0.15, tablelegP = 0.2, wallP = 0.5;
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
gluLookAt(-2, 2, 5, 0, 0, 0, 0, 1, 0);
light(); //Adding light source to your project
teapot(0, teapotP, 0); //Create teapot
tableTop(0, tabletopP, 0); //Create table’s top
tableLeg(tablelegP, -0.3, tablelegP); //Create 1st leg
tableLeg(-tablelegP, -0.3, tablelegP); //Create 2nd leg
tableLeg(-tablelegP, -0.3, -tablelegP); //Create 3rd leg
tableLeg(tablelegP, -0.3, -tablelegP); //Create 4th leg
wall(0, 0, -wallP); //Create 1st wall
glRotatef(90, 1, 0, 0);
wall(0, 0, wallP); //Create 2nd wall
glRotatef(90, 0, 1, 0);
wall(0, 0, wallP); //Create 3rd wall
glFlush();
void myinit()
glClearColor(0, 0, 0, 1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-1, 1, -1, 1, -1, 10);
glMatrixMode(GL_MODELVIEW);
}
int main(int argc, char **argv)
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB|GLUT_DEPTH);
glutInitWindowSize(500, 500);
glutInitWindowPosition(0, 0);
glutCreateWindow("Teapot on a table");
myinit();
glutDisplayFunc(display);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glShadeModel(GL_SMOOTH);
glEnable(GL_NORMALIZE);
glEnable(GL_DEPTH_TEST);
glutMainLoop();
}
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
PROGRAM 7:-
#include<stdlib.h>
#include<stdio.h>
#include<GL/glut.h>
typedef float point[3];
point v[]= {{0, 0, 1}, {0, 1, 0}, {-1, -0.5, 0}, {1, -0.5, 0}};
int n;
void triangle(point a,point b,point c)
glBegin(GL_POLYGON);
glVertex3fv(a);
glVertex3fv(b);
glVertex3fv(c);
glEnd();
void divide_triangle(point a,point b,point c,int n)
point v1,v2,v3;
int j;
if(n>0)
{
for(j=0; j<3; j++)
v1[j] = (a[j]+b[j])/2;
for(j=0; j<3; j++)
v2[j] = (a[j]+c[j])/2;
for(j=0; j<3; j++)
v3[j] = (c[j]+b[j])/2;
divide_triangle(a,v1,v2,n-1);
glFlush();
divide_triangle(c,v2,v3,n-1);
glFlush();
divide_triangle(b,v3,v1,n-1);
glFlush();
else(triangle(a,b,c));
void tetrahedron(int n)
glColor3f(1, 0, 0);
divide_triangle(v[0], v[1], v[2], n);
glColor3f(0, 1, 0);
divide_triangle(v[3], v[2], v[1], n);
glColor3f(0, 0, 1);
divide_triangle(v[0], v[3], v[1], n);
glColor3f(0, 0, 0);
divide_triangle(v[0], v[2], v[3], n);
void display(void)
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
tetrahedron(n);
glFlush();
void myReshape(int w,int h)
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if(w<=h)
glOrtho(-2, 2, -2*(GLfloat)h/(GLfloat)w, 2*(GLfloat)h/(GLfloat)w, -10, 10);
else
glOrtho(-2*(GLfloat)w/(GLfloat)h, 2*(GLfloat)w/(GLfloat)h, -2, 2, -10, 10);
glMatrixMode(GL_MODELVIEW);
glutPostRedisplay();
int main(int argc,char ** argv)
printf("No of Recursive steps/Division: ");
scanf("%d",&n);
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB|GLUT_DEPTH);
glutCreateWindow(" 3D Sierpinski gasket");
glutReshapeFunc(myReshape);
glutDisplayFunc(display);
glEnable(GL_DEPTH_TEST);
glClearColor(1, 1, 1, 0);
glutMainLoop();
return 0;
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
PROGRAM 8:-
//8. Develop a menu driven program to animate a flag using Bezier curve algorithm.
#include<GL/glut.h>
#include<stdio.h>
#include<math.h>
#define PI 3.1416
float theta = 0;
struct point
GLfloat x, y, z;
};
int factorial(int n)
if (n<=1)
return(1);
else
n=n*factorial(n-1);
return n;
void computeNcR(int n, int *hold_ncr_values)
int r;
for(r=0; r<=n; r++) //start from nC0, then nC1, nC2, nC3 till nCn
hold_ncr_values[r] = factorial(n) / (factorial(n-r) * factorial(r));
void computeBezierPoints(float t, point *actual_bezier_point, int number_of_control_points, point
*control_points_array, int *hold_ncr_values)
int i, n = number_of_control_points-1;
float bernstein_polynomial;
actual_bezier_point -> x = 0;
actual_bezier_point -> y = 0;
actual_bezier_point -> z = 0;
for(i=0; i < number_of_control_points; i++)
{
bernstein_polynomial = hold_ncr_values[i] * pow(t, i) * pow( 1-t, n-i);
actual_bezier_point -> x += bernstein_polynomial * control_points_array[i].x;
actual_bezier_point -> y += bernstein_polynomial * control_points_array[i].y;
actual_bezier_point -> z += bernstein_polynomial * control_points_array[i].z;
void bezier(point *control_points_array, int number_of_control_points, int number_of_bezier_points)
point actual_bezier_point;
float t;
int *hold_ncr_values, i;
hold_ncr_values = new int[number_of_control_points]; // to hold the nCr values
computeNcR(number_of_control_points-1, hold_ncr_values); // call nCr function to calculate nCr values
glBegin(GL_LINE_STRIP);
for(i=0; i<=number_of_bezier_points; i++)
t=float(i)/float(number_of_bezier_points);
computeBezierPoints(t, &actual_bezier_point, number_of_control_points, control_points_array,
hold_ncr_values);
glVertex2f(actual_bezier_point.x, actual_bezier_point.y);
}
glEnd();
delete[] hold_ncr_values;
void display()
glClear(GL_COLOR_BUFFER_BIT);
int number_of_control_points = 4, number_of_bezier_points = 20;
point control_points_array[4] = {{100, 400, 0}, {150, 450, 0}, {250, 350, 0},{300, 400, 0}};
control_points_array[1].x += 50*sin(theta * PI/180.0);
control_points_array[1].y += 25*sin(theta * PI/180.0);
control_points_array[2].x -= 50*sin((theta+30) * PI/180.0);
control_points_array[2].y -= 50*sin((theta+30) * PI/180.0);
control_points_array[3].x -= 25*sin((theta-30) * PI/180.0);
control_points_array[3].y += sin((theta-30) * PI/180.0);
theta += 2;
glPushMatrix();
glPointSize(5);
glColor3f(1, 0.4, 0.2); //Indian flag: Saffron color code
for(int i=0; i<50; i++)
glTranslatef(0, -0.8, 0 );
bezier(control_points_array, number_of_control_points, number_of_bezier_points);
glColor3f(1, 1, 1); //Indian flag: white color code
for(int i=0; i<50; i++)
glTranslatef(0, -0.8, 0);
bezier(control_points_array, number_of_control_points, number_of_bezier_points);
glColor3f(0, 1, 0); //Indian flag: green color code
for(int i=0; i<50; i++)
glTranslatef(0, -0.8, 0);
bezier(control_points_array, number_of_control_points, number_of_bezier_points);
glPopMatrix();
glLineWidth(5);
glColor3f(0.7, 0.5,0.3); //pole colour
glBegin(GL_LINES);
glVertex2f(100,400);
glVertex2f(100,40);
glEnd();
glutPostRedisplay();
glutSwapBuffers();
void init()
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0,500,0,500);
int main(int argc, char **argv)
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowPosition(0, 0);
glutInitWindowSize(500,500);
glutCreateWindow("Bezier Curve - updated");
init();
glutDisplayFunc(display);
glutMainLoop();
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
PROGRAM 9:-
// Scan-Line algorithm for filling a polygon
#include <stdlib.h>
#include <stdio.h>
#include <GL/glut.h>
float x1, x2, x3, x4, y1, y2, y3, y4; // our polygon has 4 lines - so 8 coordinates
void edgedetect(float x1, float y1, float x2, float y2, int *left_edge, int *right_edge)
float x_slope, x, temp;
int i;
if ((y2-y1)<0) // decide where to start
temp = y1;
y1 = y2;
y2 = temp;
temp = x1;
x1 = x2;
x2 = temp;
if ((y2-y1)!=0)
x_slope = (x2 - x1) / (y2 - y1);
else
x_slope = x2 - x1;
x = x1;
for (i = y1; i <= y2; i++)
if (x < left_edge[i])
left_edge[i] = x;
if (x > right_edge[i])
right_edge[i] = x;
x = x + x_slope;
void draw_pixel (int x, int y)
glColor3f (1, 1, 0);
glBegin (GL_POINTS);
glVertex2i (x, y);
glEnd ();
void scanfill (float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4)
int left_edge[500], right_edge[500];
int i, y;
for (i = 0; i <= 500; i++)
left_edge [i] = 500;
right_edge [i] = 0;
}
edgedetect (x1, y1, x2, y2, left_edge, right_edge);
edgedetect (x2, y2, x3, y3, left_edge, right_edge);
edgedetect (x3, y3, x4, y4, left_edge, right_edge);
edgedetect (x4, y4, x1, y1, left_edge, right_edge);
for (y = 0; y <= 500; y++)
if (left_edge[y] <= right_edge[y])
for (i = left_edge[y]; i <= right_edge[y]; i++)
draw_pixel (i, y);
glFlush ();
void display()
x1 = 200, y1 = 200;
x2 = 100, y2 = 300;
x3 = 200, y3 = 400;
x4 = 300, y4 = 300;
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0, 0, 1);
glBegin (GL_LINE_LOOP);
glVertex2f (x1, y1);
glVertex2f (x2, y2);
glVertex2f (x3, y3);
glVertex2f (x4, y4);
glEnd ();
scanfill (x1, y1, x2, y2, x3, y3, x4, y4);
void init()
glClearColor (1, 1, 1, 1);
gluOrtho2D (0, 499, 0, 499);
int main (int argc, char** argv)
{
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (0, 0);
glutCreateWindow ("Filling a Polygon using Scan-line Algorithm");
init ();
glutDisplayFunc (display);
glutMainLoop ();
