Scribd
Upload
0 views

OpenGL Program for Simple Animation

Uploaded by

Joseph
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
0 views

OpenGL Program for Simple Animation

Uploaded by

Joseph
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 6

OpenGL program for simple Animation

(Revolution) in C
OpenGL is a cross-language, cross-platform API for rendering 2D and 3D Vector
Graphics. Using this, we can make a lot of design as well as animations. Below is
the simple animation made using OpenGL.
Approach :
To make a picture moving, we need to understand the working procedure of a
function used to display i.e glClear(GL_COLOR_BUFFER_BIT). Its task is to
clear screen with default value after a certain time (normally, after 1/30 sec or 1/60
sec). So, if any change of coordinate happens, then it will appear to be moving as
human eye can distinguish image only which is separated by 1/16 second
(persistence of vision).
Now, the coordinates of circle are X = r*cos(?) and Y = r*sin(?) or for ellipse X =
rx*cos(?) and Y = ry*cos(?) where rx and ry are radius in X- and Y- direction
and ? is the angle.
If we vary ? from 0 to 2*pi (360 degree) at very small increase (say of 1 degree) and
draw point on that coordinate, we can make a complete circle or ellipse. We can also
make semi-circle or any arc of circle or ellipse by varying the starting and ending
value of ? (angle).
These concepts are used to draw the following Animation:

 7 horizontal parts of ellipse and 3 vertical complete ellipse as well as 1 outer


circle and one outer ellipse are used to visualise an orbit drawn by adjusting
the ? as well as radius.
 One vertical line is drawn to make the figure. Then to make it move, an other
loop is given where value of j changes with very small amount to make the
motion smoother.
 Since, we had to make all point moving in same type of motion to keep the figure
together, so equation of motion, that is, glVertex2i(x/2 – 600*cos(j), y/2 –
100*sin(j)) is given inside every inner for loop, so that it can be applied to all
points altogether.
For working on Ubuntu operating system:

gcc filename.c -lGL -lGLU -lglut -lm


where filename.c is the name of the file
with which this program is saved.

Below is the implementation in C.

// C Program to illustrate
// OpenGL animation for revolution

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

// global declaration
int x, y;
float i, j;

// Initialization function
void myInit (void)
{
// Reset background color with black (since all three argument is 0.0)
glClearColor(0.0, 0.0, 0.0, 1.0);

// Set picture color to green (in RGB model)


// as only argument corresponding to G (Green) is 1.0 and rest are 0.0
glColor3f(0.0, 1.0, 0.0);

// Set width of point to one unit


glPointSize(1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();

// Set window size in X- and Y- direction


gluOrtho2D(-780, 780, -420, 420);
}

// Function to display animation


void display (void)
{
// Outer loop to make figure moving
// loop variable j iterated up to 10000,
// indicating that figure will be in motion for large amount of time
// around 10000/6.29 = 1590 time it will revolve
// j is incremented by small value to make motion smoother
for (j = 0; j < 10000; j += 0.01)
{
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_POINTS);

// Iterate i up to 2*pi, i.e., 360 degree


// plot point with slight increment in angle,
// so, it will look like a continuous figure

// Loop is to draw outer circle


for (i = 0;i < 6.29;i += 0.001)
{
x = 200 * cos(i);
y = 200 * sin(i);
glVertex2i(x, y);

// For every loop, 2nd glVertex function is


// to make smaller figure in motion
glVertex2i(x / 2 - 600 * cos(j), y / 2 - 100 * sin(j));
}

// 7 loops to draw parallel latitude


for (i = 1.17; i < 1.97; i += 0.001)
{
x = 400 * cos(i);
y = -150 + 300 * sin(i);
glVertex2i(x, y);
glVertex2i(x / 2 - 600 * cos(j), y / 2 - 100 * sin(j));
}

for (i = 1.07; i < 2.07; i += 0.001)


{
x = 400 * cos(i);
y = -200 + 300 * sin(i);
glVertex2i(x, y);
glVertex2i(x / 2 - 600 * cos(j), y / 2 - 100 * sin(j));
}

for (i = 1.05; i < 2.09; i += 0.001)


{
x = 400 * cos(i);
y = -250 + 300 * sin(i);
glVertex2i(x, y);
glVertex2i(x / 2 - 600 * cos(j), y / 2 - 100 * sin(j));
}

for (i = 1.06; i < 2.08; i += 0.001)


{
x = 400 * cos(i);
y = -300 + 300 * sin(i);
glVertex2i(x, y);
glVertex2i(x / 2 - 600 * cos(j), y / 2 - 100 * sin(j));
}

for (i = 1.10; i < 2.04; i += 0.001)


{
x = 400 * cos(i);
y = -350 + 300 * sin(i);
glVertex2i(x, y);
glVertex2i(x / 2 - 600 * cos(j), y / 2 - 100 * sin(j));
}

for (i = 1.16; i < 1.98; i += 0.001)


{
x = 400 * cos(i);
y = -400 + 300 * sin(i);
glVertex2i(x, y);
glVertex2i(x / 2 - 600 * cos(j), y / 2 - 100 * sin(j));
}

for (i = 1.27; i < 1.87; i += 0.001)


{
x = 400 * cos(i);
y = -450 + 300 * sin(i);
glVertex2i(x, y);
glVertex2i(x / 2 - 600 * cos(j), y / 2 - 100 * sin(j));
}

// Loop is to draw vertical line


for (i = 200; i >=- 200; i--)
{
glVertex2i(0, i);
glVertex2i(-600 * cos(j), i / 2 - 100 * sin(j));
}

// 3 loops to draw vertical ellipse (similar to longitude)


for (i = 0;i < 6.29; i += 0.001)
{
x = 70 * cos(i);
y = 200 * sin(i);
glVertex2i(x, y);
glVertex2i(x / 2 - 600 * cos(j), y / 2 - 100 * sin(j));
}

for (i = 0; i < 6.29; i += 0.001)


{
x = 120 * cos(i);
y = 200 * sin(i);
glVertex2i(x, y);
glVertex2i(x / 2 - 600 * cos(j), y / 2 - 100 * sin(j));
}

for (i = 0; i < 6.29; i += 0.001)


{
x = 160 * cos(i);
y = 200 * sin(i);
glVertex2i(x, y);
glVertex2i(x / 2 - 600 * cos(j), y / 2 - 100 * sin(j));
}

// Loop to make orbit of revolution


for (i = 0; i < 6.29; i += 0.001)
{
x = 600 * cos(i);
y = 100 * sin(i);
glVertex2i(x, y);
}
glEnd();
glFlush();
}
}

// Driver Program
int main (int argc, char** argv)
{
glutInit(&argc, argv);
// Display mode which is of RGB (Red Green Blue) type
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);

// Declares window size


glutInitWindowSize(1360, 768);

// Declares window position which is (0, 0)


// means lower left corner will indicate position (0, 0)
glutInitWindowPosition(0, 0);

// Name to window
glutCreateWindow("Revolution");

// Call to myInit()
myInit();
glutDisplayFunc(display);
glutMainLoop();
}

You might also like