API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Apr 22nd, 2013
85
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 21.47 KB | None | 0 0
raw download clone embed print report
  1. #include <gl\glew.h>
  2. #include <gl\glut.h>
  3. #include <math.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6.  
  7. //doby oběhu
  8. #define MERKUR 88
  9. #define VENUSE 225
  10. #define ZEME 365
  11. #define MARS 687
  12. #define JUPITER 4331
  13. #define SATURN 10759
  14. #define URAN 30799
  15. #define NEPTUN 60190
  16. #define MESIC 28
  17.  
  18. //průměry (násobky země 6378km)
  19. #define RSLUNCE 5
  20. #define RMERKUR 0.383
  21. #define RVENUSE 0.949
  22. #define RZEME 1
  23. #define RMARS 0.533
  24. #define RJUPITER 11.209
  25. #define RSATURN 9.449
  26. #define RURAN 4.007
  27. #define RNEPTUN 3.883
  28.  
  29. //vzdálenost od slunce (AU 149597871km)
  30. #define DISTANCE 10
  31. #define DSLUNCE 0
  32. #define DMERKUR (RSLUNCE + RMERKUR + 0.4*DISTANCE)
  33. #define DVENUSE (DMERKUR + RVENUSE + 0.7*DISTANCE)
  34. #define DZEME (DVENUSE + RZEME + DISTANCE)
  35. #define DMARS (DZEME + RMARS + 1.5*DISTANCE)
  36. #define DJUPITER (DMARS + RJUPITER + 5.2*DISTANCE)
  37. #define DSATURN (DJUPITER + RSATURN + 9.5*DISTANCE)
  38. #define DURAN (DSATURN + RURAN + 19.6*DISTANCE)
  39. #define DNEPTUN (DURAN + RNEPTUN + 30*DISTANCE)
  40.  
  41. //textury
  42. GLuint textures[10];
  43.  
  44. //konstanta pro převod AU na násobky
  45. //průměru země
  46. #define AU2ER 23455.295
  47.  
  48. //definice PI
  49. #define PI 3.14159
  50.  
  51. //globální proměnné
  52. const float DEG2RAD = 3.14159/180;
  53.  
  54. enum {                                          // operace, ktere se mohou provadet s mysi:
  55.     ROTATE,                                     // rotace objektu
  56.     TRANSLATE,                                  // posun objektu
  57. } operation=ROTATE;
  58.  
  59. int   xnew=0, ynew=0, znew=20;                  // soucasna pozice mysi, ze ktere se pocitaji rotace a posuvy
  60. int   xold=0, yold=0, zold=20;                  // minula pozice mysi, ze ktere se pocitaji rotace a posuvy
  61. int   xx, yy, zz;                               // bod, ve kterem se nachazi kurzor mysi
  62.  
  63. int timerInterval=50;
  64.  
  65. float uhel = 0;
  66. //9polozek
  67. float uhly[] = {0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0};
  68. float citac[] = {0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0};
  69.  
  70. int   windowWidth;                              // sirka okna
  71. int   windowHeight;                             // vyska okna
  72.  
  73.  
  74.  
  75.  
  76. //---------------------------------------------------------------------
  77. // Materiály
  78. //---------------------------------------------------------------------
  79.  
  80. // paramatry materialu1
  81. GLfloat materialAmbient1[]={0.0f, 0.0f, 0.0f, 1.0f};    // ambientni slozka barvy materialu
  82. GLfloat materialDiffuse1[]={1.0f, 1.0f, 1.0f, 1.0f};    // difuzni slozka barvy materialu
  83. GLfloat materialSpecular1[]={1.0f,1.0f, 1.0f, 1.0f};    // barva odlesku
  84. GLfloat materialEmission1[] = {1.0,1.0,1.0,1.0};            // emise bílého světla
  85. GLfloat materialShininess1[]={50.0f};                       // faktor odlesku
  86.  
  87. // paramatry materialu2
  88. GLfloat materialEmission2[] = {0.3,0.3,0.3,1.0};           
  89.  
  90.  
  91. //---------------------------------------------------------------------
  92. // Světla
  93. //---------------------------------------------------------------------
  94.  
  95. //parametry svetla1
  96. GLfloat light_position1[]={0.0f, 0.0f, 0.0f, 1.0f}; // pozice svetla: nula na konci->smerove svetlo
  97. GLfloat lightDiffuse1[]={1.0f, 1.0f, 1.0f, 1.0f};   // difuzni slozka barvy
  98. GLfloat lightSpecular1[]={1.0f,1.0f, 1.0f, 1.0f};       // barva odlesku
  99. GLfloat lightAmbient1[]={0.0f, 0.0f, 0.0f, 1.0f};       // ambientní složka
  100.  
  101. //---------------------------------------------------------------------
  102. // Pomocné funkce
  103. //---------------------------------------------------------------------
  104.  
  105. void SetMaterial1(void){
  106.     glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, materialAmbient1);    // nastaveni ambientni slozky barvy materialu
  107.     glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, materialDiffuse1);    // nastaveni difuzni slozky barvy materialu
  108.     glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, materialSpecular1);  // nastaveni barvy odlesku
  109.     glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, materialEmission1);     // nastaveni barevne emise
  110.     glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, materialShininess1);  // nastaveni faktoru odlesku
  111. }
  112.  
  113. void SetMaterial2(void){
  114.     glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, materialEmission2);
  115. }
  116.  
  117. void SetLight1(void){
  118.     glLightfv(GL_LIGHT0,GL_POSITION,light_position1);
  119.     glLightfv(GL_LIGHT0,GL_DIFFUSE,lightDiffuse1);
  120.     glLightfv(GL_LIGHT0,GL_AMBIENT,lightAmbient1);
  121.     glLightfv(GL_LIGHT0,GL_SPECULAR,lightSpecular1);
  122.     //glEnable(GL_LIGHT0);
  123. }
  124.  
  125. //---------------------------------------------------------------------
  126. // Nacteni bitmapy ze souboru typu BMP
  127. //---------------------------------------------------------------------
  128. int bitmapLoad(int texture, const char *filename)
  129. {
  130.     FILE          *fin;
  131.     int           width, height, bpp=0;
  132.     int           size;
  133.     unsigned char *bitmap;
  134.     unsigned char bmpHeader[54]={0x42, 0x4d,        // magicke cislo souboru BMP
  135.                         0x00, 0x00, 0x00, 0x00,     // velikost souboru
  136.                         0x00, 0x00, 0x00, 0x00,     // rezervovano, vzdy nastaveno na nula
  137.                         0x36, 0x04, 0x00, 0x00,     // data offset=54
  138.                         0x28, 0x00, 0x00, 0x00,     // velikost hlavicky=40
  139.                         0x00, 0x00, 0x00, 0x00,     // sirka obrazku v pixelech=?
  140.                         0x00, 0x00, 0x00, 0x00,     // vyska obrazku v pixelech=?
  141.                         0x01, 0x00,                 // pocet bitovych rovin=1
  142.                         0x08, 0x00,                 // pocet bitu na pixel=24
  143.                         0x00, 0x00, 0x00, 0x00,     // metoda komprimace=nic
  144.                         0x00, 0x00, 0x00, 0x00,     // velikost bitmapy
  145.                         0x00, 0x00, 0x00, 0x00,     // pocet pixelu na metr v horizontalnim smeru
  146.                         0x00, 0x00, 0x00, 0x00,     // pocet pixelu na metr ve vertikalnim smeru
  147.                         0x00, 0x00, 0x00, 0x00,     // pocet pouzitych barev
  148.                         0x00, 0x00, 0x00, 0x00,     // pocet dulezitych barev
  149.     };
  150.     if (!filename) return -1;
  151.     fin=fopen(filename, "rb");
  152.     if (!fin) return -1;                            // otevreni souboru se nezdarilo
  153.     if (fread(bmpHeader, 54, 1, fin)!=1) return -1; // nacist hlavicku BMP souboru
  154.     memcpy(&width, bmpHeader+18, 4);                // sirka obrazku v pixelech
  155.     memcpy(&height, bmpHeader+22, 4);               // vyska obrazku v pixelech
  156.     memcpy(&bpp, bmpHeader+28, 2);                  // pocet bitu na pixel
  157.     if (bpp!=24) return -1;
  158.     size=width*height*3;
  159.     bitmap=(unsigned char *)malloc(size*sizeof(unsigned char));
  160.     if (fread(bitmap, size, sizeof(unsigned char), fin)!=1) return -1;// nacteni rastrovych dat
  161.     fclose(fin);
  162.     glBindTexture(GL_TEXTURE_2D, texture);
  163.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  164.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  165.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  166.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  167.     glTexImage2D(GL_TEXTURE_2D, 0, 3, width, height,// nacteni textury do GPU
  168.         0, GL_BGR_EXT, GL_UNSIGNED_BYTE, bitmap);
  169.     free(bitmap);
  170.     return 0;
  171. }
  172.  
  173. //---------------------------------------------------------------------
  174. // Nacteni a vytvoreni vsech textur
  175. //---------------------------------------------------------------------
  176. int loadTextures(void)
  177. {
  178.     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);          // zpusob ulozeni bytu v texure
  179.     glGenTextures(5, textures);                     // vytvoreni jmena textur
  180.     if (bitmapLoad(textures[0], "D:\\sun.bmp"))         exit(0);
  181.     if (bitmapLoad(textures[1], "D:\\mercury.bmp"))     exit(0);
  182.     if (bitmapLoad(textures[2], "D:\\venus.bmp"))       exit(0);
  183.     if (bitmapLoad(textures[3], "D:\\moon.bmp"))        exit(0);
  184.     if (bitmapLoad(textures[4], "D:\\earth.bmp"))       exit(0);
  185.     if (bitmapLoad(textures[5], "D:\\mars.bmp"))        exit(0);
  186. }
  187.  
  188. //---------------------------------------------------------------------
  189. // Funkce pro inicializaci vykreslovani
  190. //---------------------------------------------------------------------
  191. void onInit(void)
  192. {
  193.     glClearColor(0.0, 0.0, 0.0, 0.0);               // barva pro mazani color-bufferu
  194.     glShadeModel(GL_SMOOTH);                        // nastaveni stinovaciho rezimu
  195.     loadTextures();                                 // nacist vsechny textury
  196.     glClearDepth(1.0f);                             // barva pro mazani z-bufferu
  197.     glEnable(GL_DEPTH_TEST);                        // nastaveni funkce pro testovani hodnot v z-bufferu
  198.     glDepthFunc(GL_LESS);                           // kterou funkci vybrat pro testovani z-bufferu
  199.     glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);// vylepseni zobrazovani textur
  200.     glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);       // nastaveni vykresleni vyplnenych polygonu
  201.     //glPointSize(10.0);                              // nastaveni velikosti vykreslovanych bodu
  202.     glEnable(GL_POINT_SMOOTH);
  203.     glEnable(GL_LINE_SMOOTH);
  204.     //glutSetCursor(GLUT_CURSOR_NONE);
  205.  
  206.     glEnable(GL_LIGHTING);                      // globalni povoleni stinovani
  207.     glEnable(GL_COLOR_MATERIAL);
  208.     //SetMaterial1();
  209.     SetLight1();
  210.    
  211.    
  212. }
  213.  
  214.  
  215.  
  216. //---------------------------------------------------------------------
  217. // Nastaveni souradneho systemu v zavislosti na velikosti okna
  218. //---------------------------------------------------------------------
  219. void onResize(int w, int h)                     // argumenty w a h reprezentuji novou velikost okna
  220. {
  221.     glViewport(0, 0, w, h);                     // viditelna oblast pres cele okno
  222.     windowWidth=w;                              // zapamatovat si velikost okna
  223.     windowHeight=h;
  224. }
  225.  
  226.  
  227.  
  228. //---------------------------------------------------------------------
  229. // Nastaveni perspektivni projekce
  230. //---------------------------------------------------------------------
  231. void setPerspectiveProjection(void)
  232. {
  233.     glMatrixMode(GL_PROJECTION);                // zacatek modifikace projekcni matice
  234.     glLoadIdentity();                           // vymazani projekcni matice (=identita)
  235.     gluPerspective(70.0, (double)windowWidth/(double)windowHeight, 0.1f, 999999999.0f);// nastaveni perspektivni kamery
  236.     glMatrixMode(GL_MODELVIEW);                 // bude se menit modelova matice
  237.     glLoadIdentity();                           // nahrat jednotkovou matici
  238. }
  239.  
  240.  
  241. //--------------------------------------------------------------------
  242. // Kruh
  243. //--------------------------------------------------------------------
  244. void drawCircle(float radius){
  245.     int i;
  246.     float degInRad;
  247.     glBegin(GL_LINE_LOOP);
  248.  
  249.  
  250.     for(i=0;i<360;i++){
  251.         //glColor3d(1.0,0.0,0.0);
  252.         degInRad = i* DEG2RAD;
  253.         glVertex3f(cos(degInRad)*radius,0,sin(degInRad)*radius);
  254.     }
  255.  
  256.     glEnd();
  257.    
  258. }
  259.  
  260. //--------------------------------------------------------------------
  261. // Koule
  262. //--------------------------------------------------------------------
  263.  
  264. float GetAnglePi(int citatel, int jmenovatel){
  265.     return (((float)(citatel-1))/(float)jmenovatel)*PI;
  266. }
  267.  
  268. float GetAngleTwoPi(int citatel, int jmenovatel){
  269.     return (((float)(citatel-1))/(float)jmenovatel)*2*PI;
  270. }
  271.  
  272. float GetRatio(int level, int complete){
  273.     return ((float)level/(float)complete);
  274. }
  275.  
  276. void Ball(int rovnobezek, int poledniku,GLuint textura){
  277.    
  278.     int i,j;
  279.     float x1,x2,x3,x4;
  280.     float y1,y2,y3,y4;
  281.     float z1,z2,z3,z4;
  282.     float radian1,radian2,radian3,radian4;
  283.  
  284.    
  285.        
  286.     for (i=1;i<=rovnobezek+1;i++){
  287.        
  288.        
  289.  
  290.         radian1 = GetAnglePi(i-1,rovnobezek);
  291.         radian2 = GetAnglePi(i,rovnobezek);
  292.        
  293.        
  294.  
  295.         for (j=1;j<=poledniku;j++){
  296.            
  297.             radian3 = GetAngleTwoPi(j-1,poledniku);
  298.             radian4 = GetAngleTwoPi(j,poledniku);
  299.  
  300.            
  301.  
  302.             x1 = 0 + ( cos(radian3) * sin(radian1));
  303.             y1 = 0 + ( sin(radian3) * sin(radian1));
  304.             z1 = 0 + ( cos(radian1));
  305.  
  306.        
  307.             x2 = 0 + ( cos(radian4) * sin(radian1));
  308.             y2 = 0 + ( sin(radian4) * sin(radian1));
  309.             z2 = 0 + ( cos(radian1));
  310.  
  311.        
  312.             x3 = 0 + ( cos(radian4) * sin(radian2));
  313.             y3 = 0 + ( sin(radian4) * sin(radian2));
  314.             z3 = 0 + ( cos(radian2));
  315.  
  316.            
  317.             x4 = 0 + ( cos(radian3) * sin(radian2));
  318.             y4 = 0 + ( sin(radian3) * sin(radian2));
  319.             z4 = 0 + ( cos(radian2));
  320.  
  321.  
  322.             glPushMatrix();
  323.            
  324.             glBindTexture(GL_TEXTURE_2D,textura);
  325.             glTexParameterf(GL_TEXTURE_2D_ARRAY,GL_TEXTURE_MIN_FILTER,GL_COMBINE);
  326.            
  327.  
  328.             glBegin(GL_TRIANGLES);
  329.  
  330.             glNormal3f(x1,y1,z1);
  331.             glTexCoord2f(GetRatio(j-1,poledniku),GetRatio(i-1,rovnobezek));
  332.             glVertex3f(x1,y1,z1);
  333.  
  334.             glNormal3f(x3,y3,z3);
  335.             glTexCoord2f(GetRatio(j,poledniku),GetRatio(i,rovnobezek));
  336.             glVertex3f(x3,y3,z3);
  337.            
  338.             glNormal3f(x4,y4,z4);
  339.             glTexCoord2f(GetRatio(j-1,poledniku),GetRatio(i,rovnobezek));
  340.             glVertex3f(x4,y4,z4);
  341.  
  342.             glNormal3f(x2,y2,z2);
  343.             glTexCoord2f(GetRatio(j,poledniku),GetRatio(i-1,rovnobezek));
  344.             glVertex3f(x2,y2,z2);
  345.  
  346.             glNormal3f(x3,y3,z3);
  347.             glTexCoord2f(GetRatio(j,poledniku),GetRatio(i,rovnobezek));
  348.             glVertex3f(x3,y3,z3);
  349.  
  350.             glNormal3f(x1,y1,z1);
  351.             glTexCoord2f(GetRatio(j-1,poledniku),GetRatio(i-1,rovnobezek));
  352.             glVertex3f(x1,y1,z1);
  353.  
  354.             glEnd();
  355.             glPopMatrix();
  356.         }
  357.        
  358.     }
  359.  
  360.    
  361. }
  362.  
  363.  
  364. //--------------------------------------------------------------------
  365. // Planetky
  366. //--------------------------------------------------------------------
  367. void Planet(double radius,GLuint textura){
  368.     glEnable(GL_TEXTURE_2D);                      
  369.     glPushMatrix();
  370.     glRotatef(90,1,0,0);
  371.         glScaled(radius,radius,radius);
  372.         Ball(50,50,textura);
  373.     glPopMatrix();
  374.     glDisable(GL_TEXTURE_2D);
  375. }
  376.  
  377. void Sun()
  378. {
  379.     SetMaterial1();
  380.  
  381.     glPushMatrix();
  382.         glRotated(uhel,0,1,0);
  383.         Planet(35,textures[0]);
  384.     glPopMatrix();
  385.  
  386.     SetMaterial2();
  387. }
  388.  
  389. void Mercury(float distance){
  390.     //glColor3f(0.5,0.5,0.5);
  391.     drawCircle(distance);
  392.    
  393.     glPushMatrix();
  394.    
  395.         //rotace kolem slunce
  396.         glRotated(uhly[0],0,1,0);
  397.         glTranslatef(distance,0,0);
  398.    
  399.         glPushMatrix();
  400.             //rotace kolem osy
  401.             glRotated(uhel,0,1,0);
  402.             Planet(4,textures[1]);
  403.         glPopMatrix();
  404.  
  405.     glPopMatrix();
  406. }
  407.  
  408. void Venus(float distance){
  409.     //glColor3f(0.5,0.5,0.5);
  410.     drawCircle(distance);
  411.    
  412.     glPushMatrix();
  413.    
  414.         //rotace kolem slunce
  415.         glRotated(uhly[1],0,1,0);
  416.         glTranslatef(distance,0,0);
  417.    
  418.         glPushMatrix();
  419.             //rotace kolem osy
  420.             glRotated(uhel,0,1,0);
  421.             Planet(10,textures[2]);
  422.         glPopMatrix();
  423.  
  424.     glPopMatrix();
  425. }
  426.  
  427. void Moon(float distance){
  428.    
  429.     drawCircle(distance);
  430.  
  431.     glPushMatrix();
  432.         //rotace kolem země
  433.         glRotatef(uhly[3],0,1,0);
  434.         glTranslatef(distance,0,0);
  435.  
  436.         glPushMatrix();
  437.             glRotated(uhel,0,1,0);
  438.             Planet(4,textures[3]);
  439.         glPopMatrix();
  440.  
  441.     glPopMatrix();
  442. }
  443.  
  444. void Earth(float distance){
  445.     //glColor3f(0.5,0.5,0.5);
  446.     drawCircle(distance);
  447.    
  448.     glPushMatrix();
  449.  
  450.         //rotace kolem slunce
  451.         glRotated(uhly[2],0,1,0);
  452.         glTranslatef(distance,0,0);
  453.    
  454.         glPushMatrix();
  455.             glRotated(uhel,0,1,0);
  456.             glPushMatrix();
  457.                 glRotatef(180,0,1,0);
  458.                 Planet(10,textures[4]);
  459.             glPopMatrix();
  460.         glPopMatrix();
  461.  
  462.         Moon(24);
  463.  
  464.     glPopMatrix();
  465. }
  466.  
  467. void Mars(float distance){
  468.     //glColor3f(0.5,0.5,0.5);
  469.     drawCircle(distance);
  470.    
  471.     glPushMatrix();
  472.    
  473.         //rotace kolem slunce
  474.         glRotated(uhly[1],0,1,0);
  475.         glTranslatef(distance,0,0);
  476.    
  477.         glPushMatrix();
  478.             //rotace kolem osy
  479.             glRotated(uhel,0,1,0);
  480.             Planet(5.3,textures[5]);
  481.         glPopMatrix();
  482.  
  483.     glPopMatrix();
  484. }
  485.  
  486.  
  487.  
  488. //--------------------------------------------------------------------
  489. // Tato funkce je volana pri kazdem prekresleni okna
  490. //--------------------------------------------------------------------
  491. void onDisplay(void)
  492. {
  493.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);// vymazani barvoveho a z-bufferu
  494.     setPerspectiveProjection();                 // nastaveni perspektivni kamery
  495.    
  496.     glTranslatef(0.0f, 0.0f, -50.0f);           // posun objektu dale od kamery
  497.     glTranslatef(0.0f, 0.0f, znew);             // priblizeni ci vzdaleni objektu podle pohybu kurzoru mysi
  498.     glRotatef(ynew, 1.0f, 0.0f, 0.0f);          // rotace objektu podle pohybu kurzoru mysi
  499.     glRotatef(xnew, 0.0f, 1.0f, 0.0f);
  500.  
  501.      
  502.     glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
  503.    
  504.    
  505.     glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
  506.  
  507.     //glDisable(GL_LIGHTING);
  508.    
  509.     //glMaterialfv(GL_FRONT,GL_EMISSION,materialEmission1);
  510.    
  511.  
  512.     glEnable(GL_LIGHTING);
  513.     //glMaterialfv(GL_FRONT,GL_EMISSION,materialEmission2);
  514.     Mercury(75);
  515.  
  516.     Venus(125);
  517.  
  518.     Earth(175);
  519.  
  520.     Mars(225);
  521.    
  522.     glFlush();
  523.  
  524.     Sun();
  525.    
  526.     glutSwapBuffers();                          // a prohozeni predniho a zadniho bufferu
  527. }
  528.  
  529.  
  530.  
  531. //---------------------------------------------------------------------
  532. // Tato funkce je volana pri stlaceni ASCII klavesy
  533. //---------------------------------------------------------------------
  534. void onKeyboard(unsigned char key, int x, int y)
  535. {
  536.     switch (key) {
  537.         case 27:    exit(0);            break;  // ukonceni aplikace
  538.         case 'q':   exit(0);            break;  // ukonceni aplikace
  539.  
  540.         default:                        break;
  541.     }
  542. }
  543.  
  544.  
  545. //---------------------------------------------------------------------
  546. // Tato funkce je volana pri preruseni casovacem
  547. //---------------------------------------------------------------------
  548. void onTimer(int value){
  549.     int i;
  550.     float inkrement;
  551.     inkrement = 0.2;
  552.    
  553.     uhel+=inkrement;
  554.     for(i = 0; i < 9; i++){
  555.         citac[i]+=inkrement;
  556.     }
  557.  
  558.     if(uhel >= 360) uhel-=360;
  559.     if(citac[0]>=MERKUR) citac[0]-=MERKUR;
  560.     if(citac[1]>=VENUSE) citac[1]-=VENUSE;
  561.     if(citac[2]>=ZEME) citac[2]-=ZEME;
  562.     if(citac[3]>=MESIC) citac[3]-=MESIC;
  563.     if(citac[4]>=MARS) citac[4]-=MARS;
  564.     if(citac[5]>=JUPITER) citac[5]-=JUPITER;
  565.     if(citac[6]>=SATURN) citac[6]-=SATURN;
  566.     if(citac[7]>=URAN) citac[7]-=URAN;
  567.     if(citac[8]>=NEPTUN) citac[8]-=NEPTUN;
  568.  
  569.     uhly[0] = (citac[0]/(float)MERKUR)*360;
  570.     uhly[1] = (citac[1]/(float)VENUSE)*360;
  571.     uhly[2] = (citac[2]/(float)ZEME)*360;
  572.     uhly[3] = (citac[3]/(float)MESIC)*360;
  573.     uhly[4] = (citac[4]/(float)MARS)*360;
  574.     uhly[5] = (citac[5]/(float)JUPITER)*360;
  575.     uhly[6] = (citac[6]/(float)SATURN)*360;
  576.     uhly[7] = (citac[7]/(float)URAN)*360;
  577.     uhly[8] = (citac[8]/(float)NEPTUN)*360;
  578.  
  579.     glutPostRedisplay();   
  580.     glutTimerFunc(timerInterval, onTimer, value); // znovu pustit casovac
  581. }
  582.  
  583.  
  584. //---------------------------------------------------------------------
  585. // Tato funkce je volana pri stisku ci pusteni tlacitka mysi
  586. //---------------------------------------------------------------------
  587. void onMouseButton(int button, int state, int x, int y)
  588. {
  589.     if (button==GLUT_LEFT_BUTTON) {             // pri zmene stavu leveho tlacitka
  590.         operation=ROTATE;
  591.         if (state==GLUT_DOWN) {                 // pri stlaceni tlacitka
  592.             xx=x;                               // zapamatovat pozici kurzoru mysi
  593.             yy=y;
  594.         }
  595.         else {                                  // pri pusteni tlacitka
  596.             xold=xnew;                          // zapamatovat novy pocatek
  597.             yold=ynew;
  598.         }
  599.         glutPostRedisplay();                    // prekresleni sceny
  600.     }
  601.    
  602.     if (button==GLUT_RIGHT_BUTTON) {
  603.         operation=TRANSLATE;
  604.         if (state==GLUT_DOWN) zz=y;             // pri stlaceni tlacitka zapamatovat polohu kurzoru mysi
  605.         else zold=znew;                         // pri pusteni tlacitka zapamatovat novy pocatek
  606.         glutPostRedisplay();                    // prekresleni sceny
  607.     }
  608. }
  609.  
  610.  
  611.  
  612. //---------------------------------------------------------------------
  613. // Tato funkce je volana pri pohybu mysi se stlacenym tlacitkem.
  614. // To, ktere tlacitko je stlaceno si musime predem zaznamenat do
  615. // globalni promenne stav ve funkci onMouseButton()
  616. //---------------------------------------------------------------------
  617. void onMouseMotion(int x, int y)
  618. {
  619.     switch (operation) {
  620.         case ROTATE:                            // stav rotace objektu
  621.             xnew=xold+x-xx;                     // vypocitat novou pozici
  622.             ynew=yold+y-yy;
  623.             glutPostRedisplay();                // a prekreslit scenu
  624.             break;
  625.         case TRANSLATE:                         // stav priblizeni/oddaleni objektu
  626.             znew=zold+y-zz;                     // vypocitat novou pozici
  627.             glutPostRedisplay();                // a prekreslit scenu
  628.             break;
  629.     }
  630. }
  631.  
  632.  
  633.  
  634. //---------------------------------------------------------------------
  635. // Hlavni funkce konzolove aplikace
  636. //---------------------------------------------------------------------
  637. int main(int argc, char **argv)
  638. {
  639.     glutInit(&argc, argv);                      // inicializace knihovny GLUT
  640.     glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);// nastaveni dvou barvovych bufferu a pameti hloubky
  641.     glutInitWindowPosition(30, 30);             // pocatecni pozice leveho horniho rohu okna
  642.     glutInitWindowSize(500, 500);               // pocatecni velikost okna
  643.     glutCreateWindow("Projekt");                // vytvoreni okna pro kresleni
  644.     glutDisplayFunc(onDisplay);                 // registrace funkce volane pri prekreslovani okna
  645.     glutReshapeFunc(onResize);                  // registrace funkce volane pri zmene velikosti okna
  646.     glutKeyboardFunc(onKeyboard);               // registrace funkce volane pri stlaceni klavesy
  647.     glutMouseFunc(onMouseButton);               // registrace funkce volane pri stlaceni ci pusteni tlacitka
  648.     glutMotionFunc(onMouseMotion);              // registrace funkce volane pri pohybu mysi se stlacenym tlacitkem
  649.     glutTimerFunc(timerInterval,onTimer,timerInterval);
  650.     onInit();                                   // inicializace vykreslovani
  651.     glutMainLoop();                             // nekonecna smycka, kde se volaji zaregistrovane funkce
  652.     return 0;                                   // navratova hodnota vracena operacnimu systemu
  653. }
  654.  
  655.  
  656.  
  657. //---------------------------------------------------------------------
  658. // Konec zdrojoveho souboru
  659. //------
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!