Easiest Implementation of Analog Clock in Opengl C++ Source Code. Computer Graphics

1. 
2. 
   
3. 
   
4. // GLclock.c
5. // By Saqib Khan(International Islamic University Islamabad)
6. // A openGL example program, displays a 3D clock face
7. //
8. // Keyboard inputs: [ESC] = quit
9. // 'L' = enables/disables lighting
10. // 'V' = toggle ortho/prespective view
11. 
    
12. #include <GL/glut.h>
13. #include <stdio.h>
14. #include <stdlib.h>
15. #include <math.h>
16. #include <time.h>
17. 
    
18. // define glu objects
19. 
    
20. 
    
21. GLUquadricObj *Cylinder;
22. GLUquadricObj *Disk;
23. 
    
24. struct tm *newtime;
25. time_t ltime;
26. 
    
27. GLfloat rx, ry, rz, angle;
28. 
    
29. // lighting
30. GLfloat LightAmbient[]= { 0.5f, 0.5f, 0.5f, 1.0f };
31. GLfloat LightDiffuse[]= { 0.5f, 0.5f, 0.5f, 1.0f };
32. GLfloat LightPosition[]= { 5.0f, 25.0f, 15.0f, 1.0f };
33. GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
34. 
    
35. static int light_state = 1; // light on = 1, light off = 0
36. static int view_state = 1; // Ortho view = 1, Perspective = 0
37. 
    
38. 
    
39. void Sprint( int x, int y, char *st)
40. {
41.     int l,i;
42. 
    
43.     l=strlen( st );
44.     glRasterPos3i( x, y, -1);
45.     for( i=0; i < l; i++)
46.         {
47.         glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, st[i]);
48.     }
49. 
    
50. }
51. 
    
52. static void TimeEvent(int te)
53. {
54.     int timent;
55.     int i;
56. 
    
57.     rx = 30 * cos( angle );
58.     ry = 30 * sin( angle );
59.     rz = 30 * cos( angle );
60.     angle += 0.01;
61.     if (angle > M_TWOPI) angle = 0;
62. 
    
63.     glutPostRedisplay();
64.     glutTimerFunc( 100, TimeEvent, 1);
65. }
66. 
    
67. void init(void)
68. {
69. 
    
70. 
    
71.    glClearColor (0.0, 0.0, 0.0, 0.0);
72.    glShadeModel (GL_SMOOTH);
73.    glEnable(GL_DEPTH_TEST);
74.    // Lighting is added to scene
75.    glLightfv(GL_LIGHT1 ,GL_AMBIENT, LightAmbient);
76.    glLightfv(GL_LIGHT1 ,GL_DIFFUSE, LightDiffuse);
77.    glLightfv(GL_LIGHT1 ,GL_POSITION, LightPosition);
78.    glEnable(GL_LIGHTING);
79.    glEnable(GL_LIGHT1);
80. 
    
81. 
    
82.    Cylinder = gluNewQuadric();
83.    gluQuadricDrawStyle( Cylinder, GLU_FILL);
84.    gluQuadricNormals( Cylinder, GLU_SMOOTH);
85.    gluQuadricOrientation( Cylinder, GLU_OUTSIDE);
86.    gluQuadricTexture( Cylinder, GL_TRUE);
87. 
    
88.    Disk = gluNewQuadric();
89.    gluQuadricDrawStyle( Disk, GLU_FILL);
90.    gluQuadricNormals( Disk, GLU_SMOOTH);
91.    gluQuadricOrientation( Disk, GLU_OUTSIDE);
92.    gluQuadricTexture( Disk, GL_TRUE);
93. 
    
94. 
    
95. }
96. 
    
97. void Draw_gear( void )
98. {
99. 
    
100.     int i;
101.     glPushMatrix();
102.     gluCylinder(Cylinder, 2.5, 2.5, 1, 16, 16);
103.     gluDisk(Disk, 0, 2.5, 32, 16);
104.     glTranslatef(0,0,1);
105.     gluDisk(Disk, 0, 2.5, 32, 16);
106.     glPopMatrix();
107.     for( i = 0; i < 8; i++)
108.         {
109.         glPushMatrix();
110.         glTranslatef( 0.0, 0.0, 0.50);
111.         glRotatef( (360/8) * i, 0.0, 0.0, 1.0);
112.         glTranslatef( 3.0, 0.0, 0.0);
113.         glutSolidCube( 1.0 );
114.         glPopMatrix();
115.         }
116. 
     
117. 
     
118. }
119. 
     
120. void Draw_clock( GLfloat cx, GLfloat cy, GLfloat cz )
121. {
122. 
     
123.   int hour_ticks , sec_ticks;
124.   glPushMatrix();
125. 
     
126.   glTranslatef(cx,cy,cz);
127.   glRotatef( 180, 1.0, 0.0, 0.0);
128. 
     
129. 
     
130.   glPushMatrix(); // Draw large wire cube
131.   glColor3f(1.0, 1.0, 1.0);
132.   glTranslatef( 0.0, 0.0, 6.0);
133.   glutWireCube(14.0);
134.   glPopMatrix();
135. 
     
136.   glPushMatrix(); // Draw clock face
137.   glTranslatef( 0, 0, 1.0);
138.   gluDisk(Disk, 0, 6.75, 32, 16);
139. 
     
140.   glPopMatrix();
141. 
     
142.   glPushMatrix();// Draw hour hand
143.   glColor3f(1.0, 0.5, 0.5);
144.   glTranslatef( 0, 0, 0.0);
145.   glRotatef( (360/12) * newtime->tm_hour  + (360/60) * (60 / (newtime->tm_min+1)), 0.0, 0.0, 1.0);
146.   glPushMatrix();
147.   glTranslatef(0.0, 0.0, 2.0);
148.   Draw_gear();
149.   glPopMatrix();
150.   glRotatef( 90, 1.0, 0.0, 0.0);
151.   gluCylinder(Cylinder, 0.75, 0, 4, 16, 16);
152.   glPopMatrix();
153. 
     
154.   glPushMatrix();// Draw minute hand
155.   glColor3f(1.0, 0.5, 1.0);
156.   glTranslatef( 0, 0, 0.0);
157.   glRotatef( (360/60) * newtime->tm_min, 0.0, 0.0, 1.0);
158.   glPushMatrix();
159.   glTranslatef(0.0, 0.0, 3.0);
160.   glScalef(0.5, 0.5, 1.0);
161.   Draw_gear();
162.   glPopMatrix();
163.   glRotatef( 90, 1.0, 0.0, 0.0);
164.   gluCylinder(Cylinder, 0.5, 0, 6, 16, 16);
165.   glPopMatrix();
166. 
     
167.   glPushMatrix();// Draw second hand
168.   glColor3f(1.0, 0.0, 0.5);
169.   glTranslatef( 0, 0, -0.0);
170.   glRotatef( (360/60) * newtime->tm_sec, 0.0, 0.0, 1.0);
171.   glPushMatrix();
172.   glTranslatef(0.0, 0.0, 4.0);
173.   glScalef(0.25, 0.25, 1.0);
174.   Draw_gear();
175.   glPopMatrix();
176.   glRotatef( 90, 1.0, 0.0, 0.0);
177.   gluCylinder(Cylinder, 0.25, 0, 6, 16, 16);
178.   glPopMatrix();
179. 
     
180. 
     
181.   for(hour_ticks = 0; hour_ticks < 12; hour_ticks++)
182.       {
183.       glPushMatrix();// Draw next arm axis.
184.       glColor3f(0.0, 1.0, 1.0); // give it a color
185.       glTranslatef(0.0, 0.0, 0.0);
186.       glRotatef( (360/12) * hour_ticks, 0.0, 0.0, 1.0);
187.       glTranslatef( 6.0, 0.0, 0.0);
188.       glutSolidCube(1.0);
189. 
     
190.       glPopMatrix();
191.   }
192.   for(sec_ticks = 0; sec_ticks < 60; sec_ticks++)
193.      {
194.        glPushMatrix();
195.     glTranslatef(0.0, 0.0, 0.0);
196.     glRotatef( (360/60) * sec_ticks, 0.0, 0.0, 1.0);
197.     glTranslatef(6.0, 0.0, 0.0);
198.     glutSolidCube(0.25);
199.     glPopMatrix();
200.     }
201. 
     
202. 
     
203.   glPopMatrix();
204. 
     
205. }
206. 
     
207. 
     
208. void display(void)
209. {
210. 
     
211.   time(&ltime); // Get time
212.   newtime = localtime(&ltime); // Convert to local time
213. 
     
214.   glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
215. 
     
216.   // easy way to put text on the screen.
217.   glMatrixMode (GL_PROJECTION);
218.   glLoadIdentity();
219.   glOrtho(-8.0, 8.0, -8.0, 8.0, 1.0, 60.0);
220.   glMatrixMode(GL_MODELVIEW);
221.   glLoadIdentity();
222.   glDisable(GL_LIGHTING);
223.   glDisable(GL_COLOR_MATERIAL);
224. 
     
225.   // Put view state on screen
226.   glColor3f( 1.0, 1.0, 1.0);
227.   if (view_state == 0)
228.       {
229.       Sprint(-3, -4, "Perspective view");
230.       }else Sprint(-2, -4, "Ortho view");
231. 
     
232. 
     
233.       Sprint(-4,-8, asctime(newtime));
234. 
     
235.   // Turn Perspective mode on/off
236.   if (view_state == 0)
237.      {
238.      glMatrixMode (GL_PROJECTION);
239.      glLoadIdentity();
240. 
     
241.      gluPerspective(60.0, 1, 1.0, 60.0);
242.      glMatrixMode(GL_MODELVIEW);
243.      glLoadIdentity();
244.      gluLookAt( rx, 0.0, rz, 0.0, 0.0, -14.0, 0, 1, 0);
245.      }
246. 
     
247.     if (light_state == 1)
248.       {
249.        glEnable(GL_LIGHTING);
250.        glEnable(GL_COLOR_MATERIAL);  // Enable for lighing
251.       }else
252.       {
253.       glDisable(GL_LIGHTING);
254.       glDisable(GL_COLOR_MATERIAL);  // Disable for no lighing
255.   }
256. 
     
257. Draw_clock( 0.0, 0.0, -14.0);
258. 
     
259. 
     
260. 
     
261. glutSwapBuffers();
262. }
263. 
     
264. void reshape (int w, int h)
265. {
266.    glViewport (0, 0, (GLsizei) w, (GLsizei) h);
267.    glMatrixMode (GL_PROJECTION);
268.    glLoadIdentity ();
269. }
270. 
     
271. void keyboard (unsigned char key, int x, int y)
272. {
273.    switch (key)
274.    {
275.          case 'L':
276.          light_state = abs(light_state - 1);
277.          break;
278.       case 'V':
279.          view_state = abs(view_state - 1);
280.          break;
281.       case 27:
282.          exit(0); // exit program when [ESC] key presseed
283.          break;
284.       default:
285.          break;
286.    }
287. 
     
288. 
     
289. }
290. 
     
291. int main(int argc, char** argv)
292. {
293.    glutInit(&argc, argv);
294.    glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);
295.    glutInitWindowSize (500, 500);
296.    glutInitWindowPosition (10, 10);
297.    glutCreateWindow (argv[0]);
298.    glutSetWindowTitle("GLclock");
299.    init ();
300.    glutDisplayFunc(display);
301.    glutReshapeFunc(reshape);
302.    glutKeyboardFunc(keyboard);
303.    glutTimerFunc( 10, TimeEvent, 1);
304.    glutMainLoop();
305.    return 0;
306. }
307.