# shape.cpp

Jun 29th, 2022
658
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
1.
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <math.h>
5. #include <string>
6.
7. #include <windows.h>
8. #include <GL/glut.h>
9.
10. #define pi (2*acos(0.0))
11.
12. double cameraHeight;
13. double cameraAngle;
14. int drawgrid;
15. int drawaxes;
16. double angle;
17. double rotationangle;
18.
19. struct point
20. {
21.     double x,y,z;
22. };
23.
24. void assignVal(struct point *p, double x, double y, double z)
25. {
26.     p->x = x;
27.     p->y = y;
28.     p->z = z;
29. }
30.
31. void addition(struct point *p1, struct point *p2)
32. {
33.     p1->x += p2->x;
34.     p1->y += p2->y;
35.     p1->z += p2->z;
36. }
37.
38. void subtraction(struct point *p1, struct point *p2)
39. {
40.     p1->x -= p2->x;
41.     p1->y -= p2->y;
42.     p1->z -= p2->z;
43. }
44.
45. struct point crossProduct(struct point vec1, struct point vec2)
46. {
47.     struct point product;
48.     product.x = vec1.y*vec2.z - vec2.y*vec1.z;
49.     product.y = -(vec1.x*vec2.z - vec1.z*vec2.x);
50.     product.z = vec1.x*vec2.y - vec1.y*vec2.x;
51.     return product;
52. }
53.
54. struct point rotation(struct point vec, struct point rfvec, std::string direction)
55. {
56.     struct point product = crossProduct(vec, rfvec);
57.     struct point newpos;
58.     double dir = 1;
59.     if(direction=="anticlock")
60.         dir = -1;
61.
62.     double rad = dir * (pi/(double)180)*rotationangle;
66.
67.     return newpos;
68. }
69. //pos => position of the camera
70. //u, r, l => unit vectors and all perpendicular to each other
71. struct point pos, u, r, l;
73.
74.
75.
76. void drawAxes()
77. {
78.     if(drawaxes==1)
79.     {
80.         glColor3f(1.0, 1.0, 1.0);
81.         glBegin(GL_LINES);{
82.             glVertex3f( 100,0,0);
83.             glVertex3f(-100,0,0);
84.
85.             glVertex3f(0,-100,0);
86.             glVertex3f(0, 100,0);
87.
88.             glVertex3f(0,0, 100);
89.             glVertex3f(0,0,-100);
90.         }glEnd();
91.     }
92. }
93.
94.
95. void drawGrid()
96. {
97.     int i;
98.     if(drawgrid==1)
99.     {
100.         glColor3f(0.6, 0.6, 0.6);   //grey
101.         glBegin(GL_LINES);{
102.             for(i=-8;i<=8;i++){
103.
104.                 if(i==0)
105.                     continue;   //SKIP the MAIN axes
106.
107.                 //lines parallel to Y-axis
108.                 glVertex3f(i*10, -90, 0);
109.                 glVertex3f(i*10,  90, 0);
110.
111.                 //lines parallel to X-axis
112.                 glVertex3f(-90, i*10, 0);
113.                 glVertex3f( 90, i*10, 0);
114.             }
115.         }glEnd();
116.     }
117. }
118.
119. void drawSquare(double a)
120. {
121.     //glColor3f(1.0,0.0,0.0);
123.         glVertex3f( a, a,2);
124.         glVertex3f( a,-a,2);
125.         glVertex3f(-a,-a,2);
126.         glVertex3f(-a, a,2);
127.     }glEnd();
128. }
129.
130.
132. {
133.     int i;
134.     struct point points[100];
135.     glColor3f(0.7,0.7,0.7);
136.     //generate points
137.     for(i=0;i<=segments;i++)
138.     {
141.     }
142.     //draw segments using generated points
143.     for(i=0;i<segments;i++)
144.     {
145.         glBegin(GL_LINES);
146.         {
147.             glVertex3f(points[i].x,points[i].y,0);
148.             glVertex3f(points[i+1].x,points[i+1].y,0);
149.         }
150.         glEnd();
151.     }
152. }
153.
154. void drawCone(double radius,double height,int segments)
155. {
156.     int i;
158.     struct point points[100];
159.     //generate points
160.     for(i=0;i<=segments;i++)
161.     {
164.     }
165.     //draw triangles using generated points
166.     for(i=0;i<segments;i++)
167.     {
172.
173.         glBegin(GL_TRIANGLES);
174.         {
175.             glVertex3f(0,0,height);
176.             glVertex3f(points[i].x,points[i].y,0);
177.             glVertex3f(points[i+1].x,points[i+1].y,0);
178.         }
179.         glEnd();
180.     }
181. }
182.
183.
184. void drawSphere(double radius,int slices,int stacks)
185. {
186.     struct point points[100][100];
187.     int i,j;
188.     double h,r;
189.     //generate points
190.     for(i=0;i<=stacks;i++)
191.     {
194.         for(j=0;j<=slices;j++)
195.         {
196.             points[i][j].x=r*cos(((double)j/(double)slices)*2*pi);
197.             points[i][j].y=r*sin(((double)j/(double)slices)*2*pi);
198.             points[i][j].z=h;
199.         }
200.     }
201.     //draw quads using generated points
202.     for(i=0;i<stacks;i++)
203.     {
204.         glColor3f((double)i/(double)stacks,(double)i/(double)stacks,(double)i/(double)stacks);
205.         for(j=0;j<slices;j++)
206.         {
208.                 //upper hemisphere
209.                 glVertex3f(points[i][j].x,points[i][j].y,points[i][j].z);
210.                 glVertex3f(points[i][j+1].x,points[i][j+1].y,points[i][j+1].z);
211.                 glVertex3f(points[i+1][j+1].x,points[i+1][j+1].y,points[i+1][j+1].z);
212.                 glVertex3f(points[i+1][j].x,points[i+1][j].y,points[i+1][j].z);
213.                 //lower hemisphere
214.                 glVertex3f(points[i][j].x,points[i][j].y,-points[i][j].z);
215.                 glVertex3f(points[i][j+1].x,points[i][j+1].y,-points[i][j+1].z);
216.                 glVertex3f(points[i+1][j+1].x,points[i+1][j+1].y,-points[i+1][j+1].z);
217.                 glVertex3f(points[i+1][j].x,points[i+1][j].y,-points[i+1][j].z);
218.             }glEnd();
219.         }
220.     }
221. }
222.
224. {
225.     glColor3f (1, 0, 0);
226.     struct point points[100][100];
227.     int i,j;
228.     double h,r;
229.     int stacks = 90, slices = 90;
230.     //generate points
231.     for(i=0;i<=stacks;i++)
232.     {
235.         for(j=0;j<=slices;j++)
236.         {
237.             points[i][j].x=r*cos(((double)j/(double)slices)*(pi/2));
238.             points[i][j].y=r*sin(((double)j/(double)slices)*(pi/2));
239.             points[i][j].z=h;
240.         }
241.     }
242.     //draw quads using generated points
243.     for(i=0;i<stacks;i++)
244.     {
245.         for(j=0;j<slices;j++)
246.         {
248.                 //upper hemisphere
249.                 glVertex3f(points[i][j].x,points[i][j].y,points[i][j].z);
250.                 glVertex3f(points[i][j+1].x,points[i][j+1].y,points[i][j+1].z);
251.                 glVertex3f(points[i+1][j+1].x,points[i+1][j+1].y,points[i+1][j+1].z);
252.                 glVertex3f(points[i+1][j].x,points[i+1][j].y,points[i+1][j].z);
253.             }glEnd();
254.         }
255.     }
256. }
257.
258. void drawOneForthCylinder(double radius, double height)
259. {
260.     glColor3f(0, 1, 0);
261.     int slice = 500;
262.     point points[501];
263.
264.     //generate points
265.     for(int i=0; i<=slice; i++)
266.     {
269.     }
270.
271.     for(int i=0; i<slice; i++)
272.     {
274.         {
275.             glVertex3f(points[i].x, points[i].y, 0);
276.             glVertex3f(points[i+1].x, points[i+1].y, 0);
277.             glVertex3f(points[i+1].x, points[i+1].y, height);
278.             glVertex3f(points[i].x, points[i].y, height);
279.         }
280.         glEnd();
281.     }
282. }
283.
284. void drawCubicSquare(double edge)
285. {
286.     glColor3f(1, 1, 1);
288.     {
289.         glVertex3f(edge/(double)2, 0, edge/(double)2);
290.         glVertex3f(-edge/(double)2, 0, edge/(double)2);
291.         glVertex3f(-edge/(double)2, 0, -edge/(double)2);
292.         glVertex3f(edge/(double)2, 0, -edge/(double)2);
293.     }
294.     glEnd();
295. }
296.
297. void drawCubicSphere()
298. {
299.     /// 12 -> 1/4 * Cylinders
300.     glPushMatrix();
301.     {
302.         //1
303.         glTranslatef(cheight/(double)2, cheight/(double)2, -cheight/(double)2);
305.     }
306.     glPopMatrix();
307.     //2
308.     glPushMatrix();
309.     {
310.         glTranslatef(cheight/(double)2, cheight/(double)2, -cheight/(double)2);
311.         glTranslatef(0, 0, cheight);
312.         glRotatef(-90, 0, 1, 0);
314.     }
315.     glPopMatrix();
316.
317.     //3
318.     glPushMatrix();
319.     {
320.         glTranslatef(cheight/(double)2, cheight/(double)2, -cheight/(double)2);
321.         glTranslatef(0, 0, cheight);
322.         glRotatef(90, 1, 0, 0);
324.     }
325.     glPopMatrix();
326.
327.     //4
328.     glPushMatrix();
329.     {
330.         glTranslatef(cheight/(double)2, cheight/(double)2, -cheight/(double)2);
331.         glRotatef(-90, 1, 0, 0);
332.         glRotatef(-90, 0, 1, 0);
334.     }
335.     glPopMatrix();
336.
337.     //5
338.     glPushMatrix();
339.     {
340.         glTranslatef(cheight/(double)2, cheight/(double)2, -cheight/(double)2);
341.         glRotatef(90, 0, 1, 0);
342.         glRotatef(90, 1, 0, 0);
344.     }
345.     glPopMatrix();
346.
347.     //6
348.     glPushMatrix();
349.     {
350.         glTranslatef(cheight/(double)2, cheight/(double)2, -cheight/(double)2);
351.         glTranslatef(-cheight, 0, 0);
352.         glRotatef(90, 0, 0, 1);
354.     }
355.     glPopMatrix();
356.
357.     //7
358.     glPushMatrix();
359.     {
360.         glTranslatef(cheight/(double)2, cheight/(double)2, -cheight/(double)2);
361.         glTranslatef(-cheight, 0, 0);
362.         glTranslatef(0, 0, cheight);
363.         glRotatef(-90, 0, 1, 0);
364.         glRotatef(90, 1, 0, 0);
366.     }
367.     glPopMatrix();
368.
369.     //8
370.     glPushMatrix();
371.     {
372.         glTranslatef(cheight/(double)2, cheight/(double)2, -cheight/(double)2);
373.         glTranslatef(-cheight, 0, 0);
374.         glRotatef(180, 0, 1, 0);
375.         glRotatef(90, 1, 0, 0);
377.     }
378.     glPopMatrix();
379.
380.     //9
381.     glPushMatrix();
382.     {
383.         glTranslatef(cheight/(double)2, cheight/(double)2, -cheight/(double)2);
384.         glTranslatef(-cheight, -cheight, 0);
385.         glRotatef(180, 0, 0, 1);
387.     }
388.     glPopMatrix();
389.
390.     //10
391.     glPushMatrix();
392.     {
393.         glTranslatef(cheight/(double)2, cheight/(double)2, -cheight/(double)2);
394.         glTranslatef(0, -cheight, 0);
395.         glTranslatef(0, 0, cheight);
396.         glRotatef(90, 1, 0, 0);
397.         glRotatef(-90, 0, 1, 0);
399.     }
400.     glPopMatrix();
401.
402.     //11
403.     glPushMatrix();
404.     {
405.         glTranslatef(cheight/(double)2, cheight/(double)2, -cheight/(double)2);
406.         glTranslatef(0, -cheight, 0);
407.         glRotatef(-180, 1, 0, 0);
408.         glRotatef(-90, 0, 1, 0);
410.     }
411.     glPopMatrix();
412.
413.     //12
414.     glPushMatrix();
415.     {
416.         glTranslatef(cheight/(double)2, cheight/(double)2, -cheight/(double)2);
417.         glTranslatef(0, -cheight, 0);
418.         glRotatef(-90, 0, 0, 1);
420.     }
421.     glPopMatrix();
422.
423.
424.     /// 8 -> 1/8 * Sphere
425.     glPushMatrix();
426.     {
427.         glTranslatef(cheight/(double)2, cheight/(double)2, -cheight/(double)2);
428.         //a
429.         glPushMatrix();
430.         {
431.             glTranslatef(0, 0, cheight);
433.         }
434.         glPopMatrix();
435.
436.         //b
437.         glPushMatrix();
438.         {
439.             glRotatef(-180, 1, 1, 0);
441.         }
442.         glPopMatrix();
443.
444.         //c
445.         glPushMatrix();
446.         {
447.             glTranslatef(-cheight, 0, 0);
448.             glRotatef(90, 0, 0, 1);
449.             glTranslatef(0, 0, cheight);
451.         }
452.         glPopMatrix();
453.
454.         //d
455.         glPushMatrix();
456.         {
457.             glTranslatef(-cheight, 0, 0);
458.             glRotatef(90, 0, 0, 1);
459.             glRotatef(-180, 1, 1, 0);
461.         }
462.         glPopMatrix();
463.
464.         //e
465.         glPushMatrix();
466.         {
467.             glTranslatef(-cheight, -cheight, cheight);
468.             glRotatef(180, 0, 0, 1);
470.         }
471.         glPopMatrix();
472.
473.         //f
474.         glPushMatrix();
475.         {
476.             glTranslatef(-cheight, -cheight, 0);
477.             glRotatef(-90, 0, 0, 1);
478.             glRotatef(180, 1, 0, 0);
480.         }
481.         glPopMatrix();
482.
483.         //g
484.         glPushMatrix();
485.         {
486.             glTranslatef(0, -cheight, cheight);
487.             glRotatef(-90, 0, 0, 1);
489.         }
490.         glPopMatrix();
491.
492.         //h
493.         glPushMatrix();
494.         {
495.             glTranslatef(0, -cheight, 0);
496.             glRotatef(180, 1, 0, 0);
498.         }
499.         glPopMatrix();
500.     }
501.     glPopMatrix();
502.
503.     /// Squared screen
504.     // i
505.     glPushMatrix();
506.     {
508.         drawCubicSquare(cheight);
509.     }
510.     glPopMatrix();
511.
512.     // ii
513.     glPushMatrix();
514.     {
516.         glRotatef(-90, 0, 0, 1);
517.         drawCubicSquare(cheight);
518.     }
519.     glPopMatrix();
520.
521.     // iii
522.     glPushMatrix();
523.     {
525.         glRotatef(90, 0, 0, 1);
526.         drawCubicSquare(cheight);
527.     }
528.     glPopMatrix();
529.
530.     // iv
531.     glPushMatrix();
532.     {
534.         drawCubicSquare(cheight);
535.     }
536.     glPopMatrix();
537.
538.     // v
539.     glPushMatrix();
540.     {
542.         glRotatef(90, 1, 0, 0);
543.         drawCubicSquare(cheight);
544.     }
545.     glPopMatrix();
546.
547.     //vi
548.     glPushMatrix();
549.     {
551.         glRotatef(90, 1, 0, 0);
552.         drawCubicSquare(cheight);
553.     }
554.     glPopMatrix();
555. }
556.
557.
558. void drawSS()
559. {
560.     glColor3f(1,0,0);
561.     drawSquare(20);
562.
563.     glRotatef(angle,0,0,1);
564.     glTranslatef(110,0,0);
565.     glRotatef(2*angle,0,0,1);
566.     glColor3f(0,1,0);
567.     drawSquare(15);
568.
569.     glPushMatrix();
570.     {
571.         glRotatef(angle,0,0,1);
572.         glTranslatef(60,0,0);
573.         glRotatef(2*angle,0,0,1);
574.         glColor3f(0,0,1);
575.         drawSquare(10);
576.     }
577.     glPopMatrix();
578.
579.     glRotatef(3*angle,0,0,1);
580.     glTranslatef(40,0,0);
581.     glRotatef(4*angle,0,0,1);
582.     glColor3f(1,1,0);
583.     drawSquare(5);
584. }
585.
586. void keyboardListener(unsigned char key, int x,int y){
587.     switch(key){
588.
589.         case '1':
590.             r = rotation(r, u, "anticlock");
591.             l = rotation(l, u, "anticlock");
592.             break;
593.         case '2':
594.             r = rotation(r, u, "clock");
595.             l = rotation(l, u, "clock");
596.             break;
597.         case '3':
598.             u = rotation(u, r, "anticlock");
599.             l = rotation(l, r, "anticlock");
600.             break;
601.         case '4':
602.             u = rotation(u, r, "clock");
603.             l = rotation(l, r, "clock");
604.             break;
605.         case '5':
606.             r = rotation(r, l, "anticlock");
607.             u = rotation(u, l, "anticlock");
608.             break;
609.         case '6':
610.             r = rotation(r, l, "clock");
611.             u = rotation(u, l, "clock");
612.         default:
613.             break;
614.     }
615. }
616.
617.
618. void specialKeyListener(int key, int x,int y){
619.     switch(key){
620.         case GLUT_KEY_DOWN:     //down arrow key
621.             subtraction(&pos, &l);
622.             break;
623.         case GLUT_KEY_UP:       // up arrow key
625.             break;
626.
627.         case GLUT_KEY_RIGHT:
629.             break;
630.         case GLUT_KEY_LEFT:
631.             subtraction(&pos, &r);
632.             break;
633.
634.         case GLUT_KEY_PAGE_UP:
636.             break;
637.         case GLUT_KEY_PAGE_DOWN:
638.             subtraction(&pos, &u);
639.             break;
640.
641.         case GLUT_KEY_INSERT:
642.             break;
643.
644.         case GLUT_KEY_HOME:
648.             if(cheight<=0) cheight = 0;
649.             break;
650.         case GLUT_KEY_END:
654.             if(cheight>=60)  cheight = 60;
655.             break;
656.
657.         default:
658.             break;
659.     }
660. }
661.
662.
663. void mouseListener(int button, int state, int x, int y){    //x, y is the x-y of the screen (2D)
664.     switch(button){
665.         case GLUT_LEFT_BUTTON:
666.             if(state == GLUT_DOWN){     // 2 times?? in ONE click? -- solution is checking DOWN or UP
667.                 drawaxes=1-drawaxes;
668.             }
669.             break;
670.
671.         case GLUT_RIGHT_BUTTON:
672.             //........
673.             break;
674.
675.         case GLUT_MIDDLE_BUTTON:
676.             //........
677.             break;
678.
679.         default:
680.             break;
681.     }
682. }
683.
684.
685.
686. void display(){
687.
688.     //clear the display
689.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
690.     glClearColor(0,0,0,0);  //color black
691.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
692.
693.     /********************
694.     / set-up camera here
695.     ********************/
696.     //load the correct matrix -- MODEL-VIEW matrix
697.     glMatrixMode(GL_MODELVIEW);
698.
699.     //initialize the matrix
701.
702.     //now give three info
703.     //1. where is the camera (viewer)?
704.     //2. where is the camera looking?
705.     //3. Which direction is the camera's UP direction?
706.
707.     //gluLookAt(100,100,100,    0,0,0,  0,0,1);
708.     //gluLookAt(200*cos(cameraAngle), 200*sin(cameraAngle), cameraHeight,       0,0,0,      0,0,1);
709.     gluLookAt(pos.x,pos.y,pos.z,    pos.x+l.x,pos.y+l.y,pos.z+l.z,  u.x,u.y,u.z);    //-> 0,0,200,  0,0,0,  u.x,u.y,u.z
710.
711.
712.     //again select MODEL-VIEW
713.     glMatrixMode(GL_MODELVIEW);
714.
715.
716.     /****************************
718.     ****************************/
720.
721.     drawAxes();
722.     drawGrid();
723.
724.     //glColor3f(1,0,0);
725.     //drawSquare(10);
726.
727.     //drawSS();
728.
729.     drawCubicSphere();
730.     //drawOneEightSphere(70);
731.     //drawOneForthCylinder(30, 150);
732.
733.     //drawCone(20,50,24);
734.
735.     //drawSphere(30,24,20);
736.
737.
738.
739.
740.     //ADD this line in the end --- if you use double buffer (i.e. GL_DOUBLE)
741.     glutSwapBuffers();
742. }
743.
744.
745. void animate(){
746.     angle+=0.05;
747.     //codes for any changes in Models, Camera
748.     glutPostRedisplay();
749. }
750.
751. void init(){
752.     //codes for initialization
753.     drawgrid=0;
754.     drawaxes=1;
755.     cameraHeight=150.0;
756.     cameraAngle=1.0;
757.     angle=0;
758.
759.     assignVal(&pos, 100, 100, 0);
760.     assignVal(&u, 0, 0, 1);
761.     assignVal(&r, -1/(double)sqrt(2), 1/(double)sqrt(2), 0);
762.     assignVal(&l, -1/(double)sqrt(2), -1/(double)sqrt(2), 0);
763.     rotationangle = 3;
764.
765.     a = 60;
768.
769.     //clear the screen
770.     glClearColor(0,0,0,0);
771.
772.     /************************
773.     / set-up projection here
774.     ************************/
776.     glMatrixMode(GL_PROJECTION);
777.
778.     //initialize the matrix
780.
781.     //give PERSPECTIVE parameters
782.     gluPerspective(80111000.0);
783.     //field of view in the Y (vertically)
784.     //aspect ratio that determines the field of view in the X direction (horizontally)
785.     //near distance
786.     //far distance
787. }
788.
789. int main(int argc, char **argv){
790.     glutInit(&argc,argv);
791.     glutInitWindowSize(500, 500);
792.     glutInitWindowPosition(0, 0);
793.     glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB);   //Depth, Double buffer, RGB color
794.
796.
797.     init();
798.
799.     glEnable(GL_DEPTH_TEST);    //enable Depth Testing
800.
801.     glutDisplayFunc(display);   //display callback function
802.     glutIdleFunc(animate);      //what you want to do in the idle time (when no drawing is occuring)
803.
804.     glutKeyboardFunc(keyboardListener);
805.     glutSpecialFunc(specialKeyListener);
806.     glutMouseFunc(mouseListener);
807.
808.     glutMainLoop();     //The main loop of OpenGL
809.
810.     return 0;
811. }
812.