Advertisement
Guest User

Untitled

a guest
May 25th, 2015
251
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 15.64 KB | None | 0 0
  1. #include "stdafx.h"
  2.  
  3. #include <math.h>
  4.  
  5. #include <stdlib.h>
  6.  
  7. #include "glut.h"
  8.  
  9. //#include <GL/glut.h>
  10.  
  11. #include <stdlib.h>
  12.  
  13. #include <iostream>
  14.  
  15. // stała do obsługi menu podręcznego
  16.  
  17. enum
  18.  
  19. {
  20.  
  21. EXIT // wyjście
  22.  
  23. };
  24.  
  25. double PredkoscKamery=0;
  26.  
  27. // pionowy kąt pola widzenia
  28.  
  29. GLdouble fovy = 60;
  30.  
  31. float czajnikrot=0;
  32.  
  33. // wpółrzędne położenia obserwatora
  34.  
  35. GLdouble eyex = 0;
  36.  
  37. GLdouble eyey = 0;
  38.  
  39. GLdouble eyez = 3;
  40.  
  41. GLdouble ObrotX=3.14/2.0;
  42.  
  43. GLdouble ObrotY=0;
  44.  
  45. bool KeyUP=false;
  46.  
  47. bool KeyDOWN=false;
  48.  
  49. bool KeyRIGHT=false;
  50.  
  51. bool KeyLEFT=false;
  52.  
  53. // współrzędne punktu w którego kierunku jest zwrócony obserwator,
  54.  
  55. GLdouble centerx = 0;
  56.  
  57. GLdouble centery = 0;
  58.  
  59. GLdouble centerz = -100;
  60.  
  61. int figure=0;
  62.  
  63. float kat=0;
  64.  
  65. GLuint idlisty;
  66.  
  67. // funkcja generująca scenę 3D
  68.  
  69. void GenerujListyWyswietlania()
  70.  
  71. {
  72. glColor3f(0.4,0.2,1.0);
  73. idlisty = glGenLists( 4 );
  74.  
  75. // utworzenie pierwszej listy
  76. glNewList( idlisty + 0, GL_COMPILE );
  77.  
  78. glTranslatef(0,0,10);
  79.  
  80. glutWireCube(1);
  81.  
  82. glEndList();
  83.  
  84.  
  85.  
  86. // utworzenie drugiej listy
  87. glNewList( idlisty + 1, GL_COMPILE );
  88.  
  89. glTranslatef(0,0,8);
  90.  
  91. glutSolidTeapot(1);
  92.  
  93.  
  94.  
  95. glEndList();
  96.  
  97. // utworzenie trzeciej listy
  98. glNewList( idlisty + 2, GL_COMPILE );
  99.  
  100. //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  101.  
  102. glTranslatef(0,0,10);
  103. glRotatef(90,1,0,0);
  104. glRotatef(180,0,1,0);
  105. //glowa
  106. glBegin(GL_TRIANGLE_FAN);
  107. glVertex2f(0,0);
  108. for(float kat=0;kat<=360;kat+=60)
  109. {
  110. GLfloat x,y;
  111. x=1*cos(kat/180*3.14);
  112. y=1*sin(kat/180*3.14);
  113. //glColor3f (x,y,x*y);
  114. glNormal3f(x, y, 1.0);
  115. glVertex2f(x,y);
  116. }
  117. glEnd();
  118.  
  119. glTranslatef(0,0,1);
  120. glBegin(GL_TRIANGLE_FAN);
  121. glVertex2f(0,0);
  122. for(float kat=0;kat<=360;kat+=60)
  123. {
  124. GLfloat x,y;
  125. x=1*cos(kat/180*3.14);
  126. y=1*sin(kat/180*3.14);
  127. //glColor3f (x,y,x*y);
  128. glNormal3f(x,y,0);
  129. glVertex2f(x,y);
  130. }
  131. glEnd();
  132.  
  133. glTranslatef(0,0,-1);
  134. glBegin(GL_TRIANGLE_STRIP);
  135.  
  136. for(float kat=0;kat<=360;kat+=60)
  137. {
  138. GLfloat x,y;
  139. x=1*cos(kat/180*3.14);
  140. y=1*sin(kat/180*3.14);
  141. //glColor3f (x,y,x*y);
  142. glNormal3f(x,y,0);
  143. glVertex3f(x,y,0);
  144. glVertex3f(x,y,1);
  145. }
  146. glEnd();
  147.  
  148. //trzpien
  149.  
  150. glBegin(GL_TRIANGLE_FAN);
  151. glVertex2f(0,0);
  152. for(float kat=0;kat<=360;kat+=60)
  153. {
  154. GLfloat x,y;
  155. x=0.5*cos(kat/180*3.14);
  156. y=0.5*sin(kat/180*3.14);
  157. // glColor3f (x,y,x*y);
  158. glNormal3f(x,y,-1.0);
  159. glVertex2f(x,y);
  160. }
  161. glEnd();
  162.  
  163. glTranslatef(0,0,-3);
  164. glBegin(GL_TRIANGLE_FAN);
  165. glVertex2f(0,0);
  166. for(float kat=0;kat<=360;kat+=60)
  167. {
  168. GLfloat x,y;
  169. x=0.5*cos(kat/180*3.14);
  170. y=0.5*sin(kat/180*3.14);
  171. // glColor3f (x,y,x*y);
  172. glNormal3f(x,y,0);
  173. glVertex2f(x,y);
  174. }
  175. glEnd();
  176.  
  177. glTranslatef(0,0,3);
  178. glBegin(GL_TRIANGLE_STRIP);
  179.  
  180. for(float kat=0;kat<=360;kat+=60)
  181. {
  182. GLfloat x,y;
  183. x=0.5*cos(kat/180*3.14);
  184. y=0.5*sin(kat/180*3.14);
  185. //glColor3f (x,y,x*y);
  186. glVertex3f(x,y,0);
  187. glVertex3f(x,y,-3);
  188. }
  189. glEnd();
  190.  
  191.  
  192.  
  193. glBegin(GL_LINE_LOOP);
  194. GLfloat z = 0;
  195. GLfloat zz = 0;
  196. for(float kat=0; kat<=360, z>-3; kat+=10)
  197. {
  198. if(kat > 360)
  199. kat = 0;
  200. z -= 0.004;
  201. GLfloat x,y;
  202. x=0.5*cos(kat/180*3.14);
  203. y=0.5*sin(kat/180*3.14);
  204. glColor3f (x,y,z);
  205. glVertex3f(x,y,-1.0);
  206. zz = z;
  207. }
  208. glEnd();
  209.  
  210.  
  211.  
  212. glEndList();
  213. }
  214.  
  215. void UstawKamere()
  216. {
  217. double cosx, siny, sinx;
  218.  
  219. double CelX, CelY, CelZ;
  220.  
  221. // wartości funkcji trygonometrycznych
  222.  
  223. // obliczamy tylko raz dla oszczędności
  224.  
  225. if (KeyDOWN) PredkoscKamery=-0.2;
  226.  
  227. if (KeyUP) PredkoscKamery=0.2;
  228.  
  229. if (KeyLEFT) ObrotX-=0.2;
  230.  
  231. if (KeyRIGHT) ObrotX+=0.2;
  232.  
  233. siny = sin(ObrotY);
  234.  
  235. cosx = cos(ObrotX);
  236.  
  237. sinx = sin(ObrotX);
  238.  
  239. // nowa pozycja kamery
  240.  
  241. eyex += cosx*PredkoscKamery;
  242.  
  243. eyey += siny*PredkoscKamery;
  244.  
  245. eyez += sinx*PredkoscKamery;
  246.  
  247. // punkt wycelowania kamery powinien
  248.  
  249. // znajdować się gdzieś "przed jej nosem"
  250.  
  251. CelX = eyex+cosx;
  252.  
  253. CelY = eyey+siny;
  254.  
  255. CelZ = eyez+sinx;
  256.  
  257. gluLookAt(eyex, eyey, eyez,CelX, CelY, CelZ, 0, 1, 0);
  258.  
  259. //gluLookAt( eyex, eyey, eyez, centerx, centery, centerz, 0, 1, 0 );
  260.  
  261. PredkoscKamery=0;
  262. }
  263.  
  264. void Display()
  265. {
  266. // kolor tła - zawartość bufora koloru
  267. glClearColor( 5.0, 1.0, 4.0, 1.0 );
  268.  
  269. glEnable(GL_DEPTH_TEST);
  270.  
  271. // czyszczenie bufora koloru
  272. glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
  273.  
  274. // wybór macierzy modelowania
  275. glMatrixMode( GL_MODELVIEW );
  276.  
  277. // macierz modelowania = macierz jednostkowa
  278. glLoadIdentity();
  279.  
  280. UstawKamere();
  281.  
  282. // ustawienie obserwatora
  283.  
  284. //glRotatef(kat,1,0,0);
  285.  
  286. // przesunięcie obiektu o wektor [0,0,-3]
  287.  
  288. //glTranslatef( 0, 0, 2.0 );
  289.  
  290. // kolor krawędzi sześcianu
  291.  
  292.  
  293. glColor3f( 0.4, 0.0, 1.0 );
  294.  
  295. /*glEnable(GL_LIGHTING);
  296. GLfloat ambientlight[]={1.0, 1.0, 1.0, 1.0};
  297. glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientlight);
  298. GLfloat gray[] = {0.75, 0.75, 0.75, 1.0};
  299. glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, gray);*/
  300.  
  301. glEnable(GL_COLOR_MATERIAL);
  302. glEnable(GL_LIGHTING);
  303. glEnable(GL_LIGHT0);
  304. glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
  305.  
  306. glNormal3f(0.0, -1.0, 0.0);
  307.  
  308. glEnable(GL_NORMALIZE);
  309.  
  310. GLfloat DiffuseLight1[]={1.0,1.0,1.0,1.0};
  311. GLfloat LightPosition1[]={0.0, 100.0, -100.0, 1.0};
  312. GLfloat AmbientLight[]={0.1, 0.1, 0.1, 1.0};
  313.  
  314. glLightfv( GL_LIGHT0, GL_DIFFUSE, DiffuseLight1 );
  315. glLightfv( GL_LIGHT0, GL_POSITION, LightPosition1 );
  316. glLightfv( GL_LIGHT0, GL_AMBIENT, AmbientLight );
  317.  
  318. GLfloat specular[]={1.0,1.0,1.0,1.0};
  319.  
  320. glLightfv( GL_LIGHT0, GL_SPECULAR, specular );
  321.  
  322. GLfloat specref[]={1.0,1.0,1.0,1.0};
  323. glMaterialfv(GL_FRONT, GL_SPECULAR, specref);
  324. glMateriali(GL_FRONT, GL_SHININESS, 128);
  325.  
  326. glNormal3f(0.0, 1.0, 0.0);
  327.  
  328. glEnable(GL_LIGHTING);
  329. glEnable(GL_LIGHT1);
  330. GLfloat gray[] = {0.1, 0.75, 0.3, 1.0};
  331. //GLfloat specref[]={0.1,0.5,1.0,1.0};
  332. glLightfv( GL_LIGHT1, GL_DIFFUSE, DiffuseLight1 );
  333. glLightfv( GL_LIGHT1, GL_POSITION, LightPosition1 );
  334. glLightfv( GL_LIGHT1, GL_AMBIENT, AmbientLight );
  335. glMaterialfv(GL_FRONT, GL_SPECULAR, specref);
  336. glMateriali(GL_FRONT, GL_SHININESS, 128);
  337.  
  338. glLightfv( GL_LIGHT1, GL_SPECULAR, specular );
  339.  
  340.  
  341.  
  342. // glutWireCube(1);
  343. switch (figure)
  344. {
  345. case 1:
  346. glCallList(idlisty+0);
  347. break;
  348.  
  349. case 2:
  350. glCallList(idlisty+1);
  351. break;
  352.  
  353. case 3:
  354. glCallList(idlisty+2);
  355. break;
  356. }
  357.  
  358. // skierowanie poleceń do wykonania
  359. glFlush();
  360.  
  361. // zamiana buforów koloru
  362. glutSwapBuffers();
  363.  
  364. }
  365.  
  366. // zmiana wielkości okna
  367.  
  368. void Reshape( int width, int height )
  369. {
  370. // obszar renderingu - całe okno
  371. glViewport( 0, 0, width, height );
  372.  
  373. // wybór macierzy rzutowania
  374. glMatrixMode( GL_PROJECTION );
  375.  
  376. // macierz rzutowania = macierz jednostkowa
  377. glLoadIdentity();
  378.  
  379. // obliczenie aspektu obrazu z uwzględnieniem
  380. // przypadku, gdy wysokość obrazu wynosi 0
  381. GLdouble aspect = 1;
  382.  
  383. if( height > 0 )
  384.  
  385. aspect = width /( GLdouble ) height;
  386.  
  387. // rzutowanie perspektywiczne
  388. gluPerspective( fovy, aspect, 0.01, 100.0 );
  389.  
  390. // generowanie sceny 3D
  391. Display();
  392. }
  393.  
  394. // obsługa klawiatury
  395.  
  396. void Klawisze( unsigned char key, int x, int y )
  397.  
  398. {
  399. // klawisz +
  400. if( key == '+' && fovy < 180 )
  401. fovy++;
  402.  
  403. // klawisz -
  404. if( key == '-' && fovy > 0 )
  405. fovy--;
  406.  
  407. if( key == 'a' && fovy > 0 )
  408. kat++;
  409.  
  410. if( key == 'w' )
  411. PredkoscKamery=0.02;
  412.  
  413. if( key == 's' )
  414. PredkoscKamery=-0.02;
  415.  
  416. if( key == 'e' )
  417. ObrotX+=0.02;
  418.  
  419. if( key == 'q' )
  420. ObrotX-=0.02;
  421.  
  422. if( key == 'r' )
  423. ObrotY+=0.02;
  424.  
  425. if( key == 'f' )
  426. ObrotY-=0.02;
  427.  
  428. // odrysowanie okna
  429. Reshape( glutGet( GLUT_WINDOW_WIDTH ), glutGet( GLUT_WINDOW_HEIGHT ) );
  430. }
  431.  
  432. void KlawiszeSpecjalne( int key, int x, int y )
  433. {
  434. switch( key )
  435. {
  436. // kursor w lewo
  437. case GLUT_KEY_LEFT:
  438. eyex += 0.1;
  439. break;
  440.  
  441. // kursor w górę
  442. case GLUT_KEY_UP:
  443. eyey -= 0.1;
  444. break;
  445.  
  446. // kursor w prawo
  447. case GLUT_KEY_RIGHT:
  448. eyex -= 0.1;
  449. break;
  450.  
  451. // kursor w dół
  452. case GLUT_KEY_DOWN:
  453. eyey += 0.1;
  454. break;
  455. }
  456. // odrysowanie okna
  457. Reshape( glutGet( GLUT_WINDOW_WIDTH ), glutGet( GLUT_WINDOW_HEIGHT ) );
  458. }
  459.  
  460. // obsługa menu podręcznego
  461.  
  462. void Menu( int value )
  463. {
  464.  
  465. switch( value )
  466. {
  467. // wyjście
  468. case EXIT:
  469.  
  470. exit( 0 );
  471.  
  472. // wyjście
  473. case 1:
  474.  
  475. figure=1;
  476.  
  477. break;
  478.  
  479. case 2:
  480.  
  481. figure=2;
  482.  
  483. break;
  484.  
  485. case 3:
  486.  
  487. figure=3;
  488.  
  489. break;
  490.  
  491. }
  492.  
  493. Reshape( glutGet( GLUT_WINDOW_WIDTH ), glutGet( GLUT_WINDOW_HEIGHT ) );
  494. }
  495.  
  496. void KeyDown(int key,int x,int y)
  497. {
  498.  
  499. switch(key){
  500.  
  501. case GLUT_KEY_UP:
  502.  
  503. KeyUP=true;
  504.  
  505. break;
  506.  
  507. case GLUT_KEY_DOWN:
  508.  
  509. KeyDOWN=true;
  510.  
  511. break;
  512.  
  513. case GLUT_KEY_LEFT:
  514.  
  515. KeyLEFT=true;
  516.  
  517.  
  518. break;
  519.  
  520. case GLUT_KEY_RIGHT:
  521.  
  522. KeyRIGHT=true;
  523.  
  524. break;
  525. }
  526. }
  527.  
  528. void KeyUp(int key,int x,int y)
  529. {
  530.  
  531. switch(key)
  532. {
  533. case GLUT_KEY_UP:
  534. KeyUP=false;
  535. break;
  536.  
  537. case GLUT_KEY_DOWN:
  538. KeyDOWN=false;
  539. break;
  540.  
  541. case GLUT_KEY_LEFT:
  542. KeyLEFT=false;
  543. break;
  544.  
  545. case GLUT_KEY_RIGHT:
  546. KeyRIGHT=false;
  547. break;
  548. }
  549. }
  550.  
  551. int main( int argc, char * argv[] )
  552. {
  553. // inicjalizacja biblioteki GLUT
  554. glutInit( & argc, argv );
  555.  
  556. // inicjalizacja bufora ramki
  557. glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
  558.  
  559. // rozmiary głównego okna programu
  560. glutInitWindowSize( 400, 400 );
  561.  
  562. // utworzenie głównego okna programu
  563. #ifdef WIN32
  564. glutCreateWindow( "Sześcian 3" );
  565. #else
  566. glutCreateWindow( "Szescian 3" );
  567. #endif
  568.  
  569. // dołączenie funkcji generującej scenę 3D
  570. glutDisplayFunc( Display );
  571.  
  572. // dołączenie funkcji wywoływanej przy zmianie rozmiaru okna
  573. glutReshapeFunc( Reshape );
  574.  
  575. // dołączenie funkcji obsługi klawiatury
  576. glutKeyboardFunc( Klawisze );
  577.  
  578. // dołączenie funkcji obsługi klawiszy funkcyjnych i klawiszy kursora
  579. // glutSpecialFunc( KlawiszeSpecjalne );
  580.  
  581. glutSpecialFunc(KeyDown);
  582.  
  583. glutSpecialUpFunc(KeyUp);
  584.  
  585. // utworzenie menu podręcznego
  586. glutCreateMenu( Menu );
  587.  
  588. // dodanie pozycji do menu podręcznego
  589. glutAddMenuEntry( "Wyjście", EXIT );
  590. glutAddMenuEntry( "Rys1", 1 );
  591. glutAddMenuEntry( "Rys2", 2 );
  592. glutAddMenuEntry( "Rys3", 3 );
  593.  
  594. // określenie przycisku myszki obsługującej menu podręczne
  595. glutAttachMenu( GLUT_RIGHT_BUTTON );
  596.  
  597. GenerujListyWyswietlania();
  598.  
  599. glutIdleFunc(Display);
  600. // wprowadzenie programu do obsługi pętli komunikatów
  601. glutMainLoop();
  602. return 0;
  603. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement