Scribd
Upload
14 views

OpenGL Program for Simple Animation

Uploaded by

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

OpenGL Program for Simple Animation

Uploaded by

Joseph
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
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