Circle Rotation Around X-Axis Y-Axis Z-AXis, C++ Source Code, Opengl, Computer Graphics,

#include <windows.h>
#include <GL/gl.h>
#include <GL/glut.h>
#include<iostream>
#include<math.h>
using namespace std;
float angle=1.0;
void createcircle () {
// Create the circle in the coordinates origin
const int sides = 20;  // The amount of segment to create the circle
const double radius = 10; // The radius of the circle
 glBegin(GL_LINE_LOOP);
 for (int a = 0; a < 360; a += 360 / sides)
  {
    double heading = a * 3.1415926535897932384626433832795 / 180;
    glVertex2d(cos(heading) * radius, sin(heading) * radius);
  }

glEnd();
}

void RotateCircle(void)
{
  glClear(GL_COLOR_BUFFER_BIT);
  glColor3f(1.0, 1.0, 1.0);

  glMatrixMode(GL_MODELVIEW);

    glTranslatef(0,3,0);
    glRotatef(angle, 1.0, 0.0, 0.0);
    //glRotatef(angle, 0.0, 1.0, 0.0);
    //glRotatef(angle, 0.0, 0.0, 1.0);
    createcircle();
    glutSwapBuffers();

}


int main(int argc, char **argv)
{
  glutInit(&argc, argv);
  glutInitWindowSize(500, 500);
  glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
  glutCreateWindow("Assignment# 3");
  glutDisplayFunc(RotateCircle);
  glutIdleFunc(RotateCircle);
  glOrtho(-30.0, 30.0, -30.0, 30.0, -30.0, 30.0);
  glutMainLoop();
  return(0);
}
// //    #include <GL/gl.h>
//#include <math.h>
//#include <GL/glut.h>
//
//
//typedef struct
//{
//float x;
//float y;
//}CIRCLE;
//
//CIRCLE circle;
//
//float rot = 0;
//
//void createcircle (int k, int r, int h) {
//    glBegin(GL_LINES);
//    for (double i = 0; i < 180; i++)
//    {
//    circle.x = r * cos(i) - h;
//    circle.y = r * sin(i) + k;
//    glVertex3f(circle.x + k,circle.y - h,0);
//   
//    circle.x = r * cos(i + 0.1) - h;
//    circle.y = r * sin(i + 0.1) + k;
//    glVertex3f(circle.x + k,circle.y - h,0);
//    }
//    glEnd();
//}
//
//void display (void) {
//    glClearColor (0.0,0.0,0.0,1.0);
//    glClear (GL_COLOR_BUFFER_BIT);
//    glLoadIdentity();
//    glTranslatef(0,0,-20);
//    glRotatef(rot,0,1,0);
//    glRotatef(rot,1,0,0);
//    glRotatef(rot,0,0,1);
//    glColor3f(1,1,1);
//    createcircle(0,10,0);
//    glRotatef(rot,0,1,0);
//    glRotatef(rot,1,0,0);
//    glRotatef(rot,0,0,1);
//    glColor3f(1,0,0);
//    createcircle(-2,8,-2);
//    glRotatef(rot,0,1,0);
//    glRotatef(rot,1,0,0);
//    glRotatef(rot,0,0,1);
//    glColor3f(0,1,0);
//    createcircle(-1,6,-1);
//    glRotatef(rot,0,1,0);
//    glRotatef(rot,1,0,0);
//    glRotatef(rot,0,0,1);
//    glColor3f(0,0,1);
//    createcircle(2,4,2);
//    glRotatef(rot,0,1,0);
//    glRotatef(rot,1,0,0);
//    glRotatef(rot,0,0,1);
//    glColor3f(0,1,1);
//    createcircle(1,2,1);
//    glutSwapBuffers();
//    rot++;
//}
//
//void reshape (int w, int h) {
//    glViewport (0, 0, (GLsizei)w, (GLsizei)h);
//    glMatrixMode (GL_PROJECTION);
//    glLoadIdentity ();
//    gluPerspective (60, (GLfloat)w / (GLfloat)h, 0.1, 100.0);
//    glMatrixMode (GL_MODELVIEW);
//}
//
//int main (int argc, char **argv) {
//    glutInit (&argc, argv);
//    glutInitDisplayMode (GLUT_DOUBLE);
//    glutInitWindowSize (500, 500);
//    glutInitWindowPosition (100, 100);
//    glutCreateWindow ("A basic OpenGL Window");
//
//    glutDisplayFunc (display);
//    glutIdleFunc (display);
//    glutReshapeFunc (reshape);
//    glutMainLoop ();
//    return 0;
//}

Bresmen's Ellipse Algorithm for Ellipse Drawing in all vertices C++ Source Code OpengL VS-2012 Computer Graphics

#include <glut.h>
using namespace std;
void Start_Line( );
void Set_Graphics( int, int );
//void Line_Algo( int, int, int, int );

int main( int argc, char** argv  )
{
   
    glutInit( &argc, argv );
    glutInitWindowSize( 640,480);
    glutInitWindowPosition( 100, 150 );
    glutInitDisplayMode( GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH );
    glutCreateWindow( " Elipse Drawing" );
    glutDisplayFunc( Start_Line );
    Set_Graphics( 100, 100 /*window_width, window_height*/ );
    glutMainLoop( );
    return 0;
}

void drawDot (GLint x, GLint y, GLfloat r, GLfloat g, GLfloat b)
{ glColor3f(r,g,b);
  glBegin (GL_POINTS);
      glVertex2i (x,y);
  glEnd();
}

void symmetricPixels (int x, int y, int xc, int yc, float r, float g, float b)
{ drawDot (xc + x, yc + y, r,g,b);
  drawDot (xc - x, yc + y,r,g,b);
  drawDot (xc + x, yc - y,r,g,b);
  drawDot (xc - x, yc - y,r,g,b);
}

void Ellipse (int a, int b, int xc, int yc, float r, float g, float bl)
{ int aSq,bSq,twoASq,twoBSq,d,dx,dy,x,y;

  aSq = a*a;
  bSq = b*b;
  twoASq = 2*aSq;
  twoBSq = 2*bSq;
  d = bSq - b*aSq + aSq/4;
  dx = 0;
  dy = twoASq*b;
  x = 0;
  y = b;
  symmetricPixels(x,y,xc,yc,r,g,bl);
  while (dx < dy)
  { x++;
    dx += twoBSq;
    if (d >= 0)
    { y--;
      dy -= twoASq;
    }
    if (d < 0)
     d += bSq + dx;
    else
     d += bSq + dx - dy;
    symmetricPixels (x,y,xc,yc,r,g,bl);
  }
  d = (int)(bSq*(x+0.5)*(x+0.5) + aSq*(y-1)*(y-1) -
                 aSq*bSq);
  while (y > 0)
  { y--;
    dy -= twoASq;
    if (d <= 0)
    { x++;
      dx += twoBSq;
    }
    if (d > 0)
         d += aSq - dy;
    else
         d += aSq -dy +dx;
    symmetricPixels(x,y,xc,yc,r,g,bl);
  }
}   
void Set_Graphics( int width, int height )
{
    glClearColor( 1.0, 1.0, 1.0, 0.0 );
    glColor3f( 0.0f, 0.0f, 0.0f );
    glViewport( 0, 0, width, height );
    glMatrixMode( GL_PROJECTION );   
    glLoadIdentity( );
    glEnable( GL_DEPTH_TEST );
    gluPerspective( 45, ( float ) width / height, 1.0, 0 );
    glMatrixMode( GL_MODELVIEW );
    glTranslatef( 0, 0, 5 * ( -height) );
}
void Start_Line( )
{
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
//    Line_Algo( 5, 8, 29,32 );
//    Circle (40,0,0,1);
    Ellipse (100,30,20,20,0,1,0);
  // glFlush();
    glutSwapBuffers( );
}

Bresmen's Circle Algorithm for Circle Drawing in all vertices C++ Source Code OpengL VS-2012 Computer Graphics

#include <glut.h>
using namespace std;
void Start_Line( );
void Set_Graphics( int, int );
//void Line_Algo( int, int, int, int );

int main( int argc, char** argv  )
{
   
    glutInit( &argc, argv );
    glutInitWindowSize( 600,600);
    glutInitWindowPosition( 100, 150 );
    glutInitDisplayMode( GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH );
    glutCreateWindow( " Circle Drawing" );
    glutDisplayFunc( Start_Line );
    Set_Graphics( 100, 100 /*window_width, window_height*/ );
    glutMainLoop( );
    return 0;
}

void drawDot (GLint x, GLint y, GLfloat r, GLfloat g, GLfloat b)
{ glColor3f(r,g,b);
  glBegin (GL_POINTS);
      glVertex2i (x,y);
  glEnd();
}

void circlePoints (int x, int y, float r, float g, float b)
{
  drawDot (x,y,r,g,b);
  drawDot (-x,y,r,g,b);
  drawDot (x,-y,r,g,b);
  drawDot (-x,-y,r,g,b);
  drawDot (y,x,r,g,b);
  drawDot (-y,x,r,g,b);
  drawDot (y,-x,r,g,b);
  drawDot (-y,-x,r,g,b);
}

void Circle (int rad, float r, float g, float b)
{ int x,y,d;
 
  x = 0;
  y = rad;
  circlePoints (x,y,r,g,b);
  d = 1 - rad;
  while (y>x)
  {
    if (d < 0)
     { d += 2*x +3;
    x++;}
    else{
     d += 2*(x-y) + 5;
     x++;y--;}
    circlePoints (x,y,r,g,b);
   
   
  }
}
void Set_Graphics( int width, int height )
{
    glClearColor( 1.0, 1.0, 1.0, 0.0 );
    glColor3f( 0.0f, 0.0f, 0.0f );
    glViewport( 0, 0, width, height );
    glMatrixMode( GL_PROJECTION );   
    glLoadIdentity( );
    glEnable( GL_DEPTH_TEST );
    gluPerspective( 45, ( float ) width / height, 1.0, 0 );
    glMatrixMode( GL_MODELVIEW );
    glTranslatef( 0, 0, 5 * ( -height) );
}
void Start_Line( )
{
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
//    Line_Algo( 5, 8, 29,32 );
    Circle (100,0,0,1);
    glRotatef(1.0, 1.0, 0.0, 0.0);
    glutSwapBuffers( );
}

Bresmen's Line Algorithm for Line Drawing in all vertices C++ Source Code OpengL VS-2012 Computer Graphics

#include <glut.h>
using namespace std;
void Start_Line( );
void Set_Graphics( int, int );
void Line_Algo( int, int, int, int );

int main( int argc, char** argv  )
{
   
    glutInit( &argc, argv );
    glutInitWindowSize( 800,600);
    glutInitDisplayMode( GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH );
    glutCreateWindow( " Line Drawing" );
    glutDisplayFunc( Start_Line );
    Set_Graphics( 100, 100 /*window_width, window_height*/ );
    glutMainLoop( );
    return 0;
}

void DrawPixel( int x_Axis, int y_Axis )
{
    glPointSize( 2.0 );
    glBegin( GL_POINTS );
    glVertex2i( x_Axis, y_Axis );
    glEnd( );
    glFlush( );
}

void Line_Algo( int starting_X, int starting_Y, int ending_X, int ending_Y )
{    int delta, deltaX, deltaY, x_Axis, y_Axis, slope, increment_E, increment_NE;

    if( starting_X > ending_X )
    {
        Line_Algo( ending_X, ending_Y, starting_X, starting_Y );
        return;
    }

    deltaX = ending_X - starting_X;
    deltaY = ending_Y - starting_Y;

    if( deltaY < 0 )
    {
        slope = -1;
        deltaY = - deltaY;
    }
    else
    {
        slope = 1;
    }

    increment_E = 2 * deltaY;
    increment_NE = 2 * ( deltaY - deltaX );

    delta = 2 * deltaY - deltaX;

    x_Axis = starting_X;
    y_Axis = starting_Y;

while( x_Axis < ending_X )
    {
        DrawPixel( x_Axis, y_Axis );

        if( delta < 0 )
        {
            delta += increment_E;
            x_Axis ++;
        }
        else
        {
            delta += increment_NE;
            y_Axis += slope;
            x_Axis++;
        }
       
    }
}
void Set_Graphics( int width, int height )
{
    glClearColor( 1.0, 1.0, 1.0, 0.0 );
    glColor3f( 0.0f, 0.0f, 0.0f );
    gluPerspective( 45, ( float ) width / height, 1.0, 0 );
    glMatrixMode( GL_MODELVIEW );
    glTranslatef( 0, 0, 5 * ( -height) );
}
void Start_Line( )
{
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
    Line_Algo( 0, 0, 40,-40);
    glutSwapBuffers( );
}

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.