API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 13th, 2017
88
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 14.89 KB | None | 0 0
raw download clone embed print report
  1. //jajko bez wektorów normalnych
  2. ************************************************************************************* /
  3.  
  4. // Szkielet programu do tworzenia modelu sceny 3-D z wizualizacj? osi
  5. // uk?adu wspó?rz?dnych dla rzutowania perspektywicznego
  6.  
  7. /*************************************************************************************/
  8. #include "stdafx.h"
  9. #include <windows.h>
  10. #include <gl/gl.h>
  11. #include <gl/glut.h>
  12. #include <iostream>
  13. #include <math.h>
  14. #define PI 3.14159265358979323846
  15. using namespace std;
  16.  
  17. typedef float point3[3];
  18.  
  19. static GLfloat viewer[] = { 0.0, 0.0, 10.0 };
  20. // inicjalizacja po?o?enia obserwatora
  21.  
  22. /*************************************************************************************/
  23.  
  24. // Funkcja rysuj?ca osie uk?adu wspó?rz?dnych
  25.  
  26. static GLfloat theta = 0.0; // k?t obrotu obiektu
  27. static GLfloat theta2 = 0.0; // k?t obrotu obiektu
  28. static GLfloat pix2angle_x; // przelicznik pikseli na stopnie
  29. static GLfloat pix2angle_y; // przelicznik pikseli na stopnie
  30.  
  31. static GLint status = 0; // stan klawiszy myszy
  32. // 0 - nie naci?ni?to ?adnego klawisza
  33. // 1 - naci?ni?ty zosta? lewy klawisz
  34. // 2 - naciśnięty prawy klawisz
  35.  
  36. static int x_pos_old = 0; // poprzednia pozycja kursora myszy
  37. static int y_pos_old = 0;
  38. static int z_pos_old = 0;
  39.  
  40. static int delta_x = 0; // ró?nica pomi?dzy pozycj? bie??c? i poprzedni? kursora myszy
  41. static int delta_y = 0;
  42. static int delta_z = 0;
  43.  
  44. int model = 1;
  45. const int N = 100;
  46. typedef float point3[3];
  47.  
  48.  
  49. double R = 10;
  50. float fi = 0.0;
  51.  
  52.  
  53.  
  54. struct Coordinates
  55. {
  56. double x;
  57. double y;
  58. double z;
  59. };
  60.  
  61. Coordinates Point[N][N];
  62. Coordinates Color[N][N];
  63.  
  64. void Newcoords()//wyliczanie współrzędnych za pomocą wzoru
  65. {
  66. for (int i = 0; i < N; i++)
  67. {
  68. for (int j = 0; j < N; j++)
  69. {
  70. double u = (double)(i) / (N - 1);
  71. double v = (double)(j) / (N - 1);
  72. Point[i][j].x = (-90 * pow(u, 5) + 225 * pow(u, 4) - 270 * pow(u, 3) + 180 * pow(u, 2) - 45 * u) * cos(PI*v);
  73. Point[i][j].y = 160 * pow(u, 4) - 320 * pow(u, 3) + 160 * pow(u, 2);
  74. Point[i][j].z = (-90 * pow(u, 5) + 225 * pow(u, 4) - 270 * pow(u, 3) + 180 * pow(u, 2) - 45 * u) * sin(PI*v);
  75. }
  76. }
  77. }
  78.  
  79.  
  80. void Colors()//losowanie i przydzielanie kolorów do tablicy
  81. {
  82. for (int i = 0; i < N; i++)
  83. {
  84. for (int j = 0; j < N; j++)
  85. {
  86. Color[i][j].x = float(rand() % 100) / 100;
  87. Color[i][j].y = float(rand() % 100) / 100;
  88. Color[i][j].z = float(rand() % 100) / 100;
  89. }
  90. }
  91. }
  92.  
  93. void Axes(void)
  94. {
  95.  
  96. point3 x_min = { -5.0, 0.0, 0.0 };
  97. point3 x_max = { 5.0, 0.0, 0.0 };
  98. // pocz?tek i koniec obrazu osi x
  99.  
  100. point3 y_min = { 0.0, -5.0, 0.0 };
  101. point3 y_max = { 0.0, 5.0, 0.0 };
  102. // pocz?tek i koniec obrazu osi y
  103.  
  104. point3 z_min = { 0.0, 0.0, -5.0 };
  105. point3 z_max = { 0.0, 0.0, 5.0 };
  106. // pocz?tek i koniec obrazu osi y
  107.  
  108. glColor3f(1.0f, 0.0f, 0.0f); // kolor rysowania osi - czerwony
  109. glBegin(GL_LINES); // rysowanie osi x
  110.  
  111. glVertex3fv(x_min);
  112. glVertex3fv(x_max);
  113.  
  114. glEnd();
  115.  
  116. glColor3f(0.0f, 1.0f, 0.0f); // kolor rysowania - zielony
  117. glBegin(GL_LINES); // rysowanie osi y
  118.  
  119. glVertex3fv(y_min);
  120. glVertex3fv(y_max);
  121.  
  122. glEnd();
  123.  
  124. glColor3f(0.0f, 0.0f, 1.0f); // kolor rysowania - niebieski
  125. glBegin(GL_LINES); // rysowanie osi z
  126.  
  127. glVertex3fv(z_min);
  128. glVertex3fv(z_max);
  129.  
  130. glEnd();
  131.  
  132. }
  133.  
  134. void Egg()
  135. {
  136. glColor3f(1.0, 1.0, 1.0);//ustal kolor rysowania - biały
  137. glTranslated(0, -5.0, 0);//przesuń jajko na środek
  138. Newcoords();
  139.  
  140. if (model == 1)
  141. {
  142. glBegin(GL_POINTS);
  143.  
  144. for (int i = 0; i < N; i++) {
  145. for (int j = 0; j < N; j++) {
  146. glVertex3d(Point[i][j].x, Point[i][j].y, Point[i][j].z);
  147. }
  148. }
  149. glEnd();
  150. }
  151.  
  152. if (model == 2)
  153. {
  154. for (int i = 0; i < N - 1; i++) {
  155. for (int j = 0; j < N - 1; j++) {
  156. //1Prosta
  157. // glColor3f(1.0, 1.0, 1.0);
  158. glBegin(GL_LINES);
  159. glVertex3d(Point[i][j].x, Point[i][j].y, Point[i][j].z);
  160. glVertex3d(Point[i][j + 1].x, Point[i][j + 1].y, Point[i][j + 1].z);
  161. glEnd();
  162. //2Prosta
  163. //glColor3f(1.0, 1.0, 0.5);
  164. glBegin(GL_LINES);
  165. glVertex3d(Point[i][j].x, Point[i][j].y, Point[i][j].z);
  166. glVertex3d(Point[i + 1][j].x, Point[i + 1][j].y, Point[i + 1][j].z);
  167. glEnd();
  168. //skos
  169. //glColor3f(1.0, 0.5, 1.0);
  170. glBegin(GL_LINES);
  171. glVertex3d(Point[i + 1][j].x, Point[i + 1][j].y, Point[i + 1][j].z);
  172. glVertex3d(Point[i][j + 1].x, Point[i][j + 1].y, Point[i][j + 1].z);
  173. glEnd();
  174.  
  175. /*2skos
  176. glColor3f(0.5, 1.0, 1.0);
  177. glBegin(GL_LINES);
  178. glVertex3d(Point[i][j].x, Point[i][j].y, Point[i][j].z);
  179. glVertex3d(Point[i + 1][j + 1].x, Point[i + 1][j + 1].y, Point[i + 1][j + 1].z);
  180. glEnd();*/
  181.  
  182. }
  183. }
  184. }
  185.  
  186. if (model == 3)
  187. {
  188.  
  189. for (int i = 0; i < N - 1; i++) {
  190. for (int j = 0; j < N - 1; j++) {
  191. //1 polowa
  192. glBegin(GL_TRIANGLES);
  193. glColor3d(Color[i][j + 1].x, Color[i][j + 1].y, Color[i][j + 1].z);
  194. glVertex3d(Point[i][j + 1].x, Point[i][j + 1].y, Point[i][j + 1].z);
  195. glColor3d(Color[i + 1][j].x, Color[i + 1][j].y, Color[i + 1][j].z);
  196. glVertex3d(Point[i + 1][j].x, Point[i + 1][j].y, Point[i + 1][j].z);
  197. glColor3d(Color[i + 1][j + 1].x, Color[i + 1][j + 1].y, Color[i + 1][j + 1].z);
  198. glVertex3d(Point[i + 1][j + 1].x, Point[i + 1][j + 1].y, Point[i + 1][j + 1].z);
  199. glEnd();
  200. //2polowa
  201. glBegin(GL_TRIANGLES);
  202. glColor3d(Color[i][j].x, Color[i][j].y, Color[i][j].z);
  203. glVertex3d(Point[i][j].x, Point[i][j].y, Point[i][j].z);
  204. glColor3d(Color[i + 1][j].x, Color[i + 1][j].y, Color[i + 1][j].z);
  205. glVertex3d(Point[i + 1][j].x, Point[i + 1][j].y, Point[i + 1][j].z);
  206. glColor3d(Color[i][j + 1].x, Color[i][j + 1].y, Color[i][j + 1].z);
  207. glVertex3d(Point[i][j + 1].x, Point[i][j + 1].y, Point[i][j + 1].z);
  208. glEnd();
  209. }
  210. }
  211. }
  212.  
  213. }
  214. /*************************************************************************************/
  215.  
  216. // Funkcja "bada" stan myszy i ustawia warto?ci odpowiednich zmiennych globalnych
  217.  
  218. void Mouse(int btn, int state, int x, int y)
  219. {
  220.  
  221.  
  222. if (state == GLUT_DOWN)
  223. {
  224. if (btn == GLUT_LEFT_BUTTON)
  225. {
  226. x_pos_old = x; // przypisanie aktualnie odczytanej pozycji kursora
  227. y_pos_old = y; // jako pozycji poprzedniej
  228. status = 1; // wciśnięty został lewy klawisz myszy
  229. }
  230. if (btn == GLUT_RIGHT_BUTTON)//wciśnięty został prawy klawisz
  231. {
  232. y_pos_old = y;
  233. status = 2;
  234. }
  235. }
  236. else {
  237.  
  238. status = 0; // nie został wciśnięty żaden klawisz
  239. }
  240. }
  241.  
  242. /*************************************************************************************/
  243.  
  244. // Funkcja "monitoruje" położenie kursora myszy i ustawia wartości odpowiednich
  245. // zmiennych globalnych
  246.  
  247. void Motion(GLsizei x, GLsizei y)
  248. {
  249.  
  250. delta_x = x - x_pos_old; // obliczenie różnicy położenia kursora myszy
  251. delta_y = y - y_pos_old;
  252. x_pos_old = x; // podstawienie bieżącego położenia jako poprzednie
  253. y_pos_old = y;
  254. glutPostRedisplay(); // przerysowanie obrazu sceny
  255. }
  256.  
  257. /*************************************************************************************/
  258.  
  259.  
  260.  
  261. /*************************************************************************************/
  262.  
  263. // Funkcja okre?laj?ca co ma by? rysowane (zawsze wywo?ywana, gdy trzeba
  264. // przerysowa? scen?)
  265.  
  266.  
  267.  
  268.  
  269. void RenderScene(void)
  270. {
  271.  
  272. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  273. // Czyszczenie okna aktualnym kolorem czyszczącym
  274.  
  275. glLoadIdentity();
  276. // Czyszczenie macierzy bieżącej
  277.  
  278.  
  279.  
  280. if (status == 1) // jeśli lewy klawisz myszy wciśnięty
  281. {
  282.  
  283.  
  284. theta += delta_x*pix2angle_x; // modyfikacja kąta obrotu o kąt proporcjonalny
  285. fi += delta_y*-pix2angle_y; // do różnicy położeń kursora myszy
  286.  
  287. /*if (fi >= 2)
  288. fi = 0;
  289. if (theta >= 2)
  290. theta = 0;*/
  291.  
  292. }
  293.  
  294. else if (status == 2) { // jeśli prawy klawisz myszy wciśnięty
  295. R += 0.1* delta_y; // modyfikacja polozenia obserwatora(zoom)
  296. if (R <= 7.0)
  297. R = 7.0;
  298. if (R >= 20.0)
  299. R = 20.0;
  300. }
  301.  
  302. viewer[0] = R * cos(theta) * cos(fi);
  303. viewer[1] = R * sin(fi);
  304. viewer[2] = R * sin(theta) * cos(fi);
  305.  
  306. gluLookAt(viewer[0], viewer[1], viewer[2], 0.0, 0.0, 0.0, 0.0, cos(fi), 0.0);
  307.  
  308. //cout << R << " R" << endl;
  309. //cout << fi << " fi" << endl;
  310. //cout << theta << " theta" << endl;
  311.  
  312.  
  313. Axes();
  314. glColor3f(1.0f, 1.0f, 1.0f);
  315. // Ustawienie koloru rysowania na bia?y
  316.  
  317. Egg();
  318. //glutWireTeapot(3.0);
  319. // Narysowanie czajnika
  320.  
  321. glFlush();
  322. // Przekazanie polece? rysuj?cych do wykonania
  323.  
  324.  
  325.  
  326. glutSwapBuffers();
  327. //
  328.  
  329. }
  330.  
  331. void keys(unsigned char key, int x, int y)
  332. {
  333. if (key == 'p') model = 1;
  334. if (key == 'w') model = 2;
  335. if (key == 's') model = 3;
  336.  
  337. RenderScene(); // przerysowanie obrazu sceny
  338. }
  339.  
  340. /*************************************************************************************/
  341.  
  342. // Funkcja ustalaj?ca stan renderowania
  343.  
  344.  
  345.  
  346. void MyInit(void)
  347. {
  348. /*************************************************************************************/
  349.  
  350. // Definicja materiału z jakiego zrobiony jest czajnik
  351. // i definicja źródła światła
  352.  
  353. /*************************************************************************************/
  354.  
  355.  
  356. /*************************************************************************************/
  357. // Definicja materiału z jakiego zrobiony jest czajnik
  358.  
  359. GLfloat mat_ambient[] = { 1.0, 1.0, 1.0, 1.0 };
  360. // współczynniki ka =[kar,kag,kab] dla światła otoczenia
  361.  
  362. GLfloat mat_diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
  363. // współczynniki kd =[kdr,kdg,kdb] światła rozproszonego
  364.  
  365. GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
  366. // współczynniki ks =[ksr,ksg,ksb] dla światła odbitego
  367.  
  368. GLfloat mat_shininess = { 20.0 };
  369. // współczynnik n opisujący połysk powierzchni
  370.  
  371. /*************************************************************************************/
  372. // Definicja źródła światła
  373.  
  374. GLfloat light_position[] = { 0.0, 0.0, 10.0, 1.0 };
  375. // położenie źródła
  376.  
  377.  
  378. GLfloat light_ambient[] = { 0.1, 0.1, 0.1, 1.0 };
  379. // składowe intensywności świecenia źródła światła otoczenia
  380. // Ia = [Iar,Iag,Iab]
  381.  
  382. GLfloat light_diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
  383. // składowe intensywności świecenia źródła światła powodującego
  384. // odbicie dyfuzyjne Id = [Idr,Idg,Idb]
  385.  
  386. GLfloat light_specular[] = { 1.0, 1.0, 1.0, 1.0 };
  387. // składowe intensywności świecenia źródła światła powodującego
  388. // odbicie kierunkowe Is = [Isr,Isg,Isb]
  389.  
  390. GLfloat att_constant = { 1.0 };
  391. // składowa stała ds dla modelu zmian oświetlenia w funkcji
  392. // odległości od źródła
  393.  
  394. //GLfloat att_linear = { 0.05 };
  395. // składowa liniowa dl dla modelu zmian oświetlenia w funkcji
  396. // odległości od źródła
  397.  
  398. //GLfloat att_quadratic = { 0.001 };
  399. // składowa kwadratowa dq dla modelu zmian oświetlenia w funkcji
  400. // odległości od źródła
  401.  
  402. /*************************************************************************************/
  403. // Ustawienie parametrów materiału i źródła światła
  404.  
  405. /*************************************************************************************/
  406. // Ustawienie patrametrów materiału
  407.  
  408.  
  409. glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
  410. glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
  411. glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
  412. glMaterialf(GL_FRONT, GL_SHININESS, mat_shininess);
  413.  
  414. /*************************************************************************************/
  415. // Ustawienie parametrów źródła
  416.  
  417. glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
  418. glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
  419. glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
  420. glLightfv(GL_LIGHT0, GL_POSITION, light_position);
  421.  
  422. glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, att_constant);
  423. glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.05);
  424. glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 0.001);
  425.  
  426.  
  427. /*************************************************************************************/
  428. // Ustawienie opcji systemu oświetlania sceny
  429.  
  430. glShadeModel(GL_SMOOTH); // właczenie łagodnego cieniowania
  431. glEnable(GL_LIGHTING); // właczenie systemu oświetlenia sceny
  432. glEnable(GL_LIGHT0); // włączenie źródła o numerze 0
  433. glEnable(GL_DEPTH_TEST); // włączenie mechanizmu z-bufora
  434.  
  435. /*************************************************************************************/
  436. glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
  437. // Kolor czyszcz?cy (wype?nienia okna) ustawiono na czarny
  438.  
  439. }
  440.  
  441. /*************************************************************************************/
  442.  
  443. // Funkcja ma za zadanie utrzymanie sta?ych proporcji rysowanych
  444. // w przypadku zmiany rozmiarów okna.
  445. // Parametry vertical i horizontal (wysoko?? i szeroko?? okna) s?
  446. // przekazywane do funkcji za ka?dym razem gdy zmieni si? rozmiar okna.
  447.  
  448. void ChangeSize(GLsizei horizontal, GLsizei vertical)
  449. {
  450. pix2angle_x = 360.0*0.1 / (float)horizontal; // przeliczenie pikseli na stopnie
  451. pix2angle_y = 360.0*0.1 / (float)vertical;
  452.  
  453. glMatrixMode(GL_PROJECTION);
  454. // Prze??czenie macierzy bie??cej na macierz projekcji
  455.  
  456. glLoadIdentity();
  457. // Czyszcznie macierzy bie??cej
  458.  
  459. gluPerspective(70, 1.0, 1.0, 30.0);
  460. // Ustawienie parametrów dla rzutu perspektywicznego
  461.  
  462.  
  463. if (horizontal <= vertical)
  464. glViewport(0, (vertical - horizontal) / 2, horizontal, horizontal);
  465.  
  466. else
  467. glViewport((horizontal - vertical) / 2, 0, vertical, vertical);
  468. // Ustawienie wielko?ci okna okna widoku (viewport) w zale?no?ci
  469. // relacji pomi?dzy wysoko?ci? i szeroko?ci? okna
  470.  
  471. glMatrixMode(GL_MODELVIEW);
  472. // Prze??czenie macierzy bie??cej na macierz widoku modelu
  473.  
  474. glLoadIdentity();
  475. // Czyszczenie macierzy bie??cej
  476.  
  477. }
  478.  
  479. /*************************************************************************************/
  480.  
  481. // G?ówny punkt wej?cia programu. Program dzia?a w trybie konsoli
  482.  
  483.  
  484.  
  485. void main(void)
  486. {
  487. Colors();
  488. glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  489.  
  490. glutInitWindowSize(300, 300);
  491.  
  492. glutCreateWindow("Rzutowanie perspektywiczne");
  493. glutKeyboardFunc(keys);
  494. glutDisplayFunc(RenderScene);
  495. // Okre?lenie, ?e funkcja RenderScene b?dzie funkcj? zwrotn?
  496. // (callback function). B?dzie ona wywo?ywana za ka?dym razem
  497. // gdy zajdzie potrzeba przerysowania okna
  498.  
  499.  
  500.  
  501. glutReshapeFunc(ChangeSize);
  502. // Dla aktualnego okna ustala funkcj? zwrotn? odpowiedzialn?
  503. // za zmiany rozmiaru okna
  504.  
  505.  
  506.  
  507. MyInit();
  508. // Funkcja MyInit() (zdefiniowana powy?ej) wykonuje wszelkie
  509. // inicjalizacje konieczne przed przyst?pieniem do renderowania
  510.  
  511. glEnable(GL_DEPTH_TEST);
  512. // W??czenie mechanizmu usuwania niewidocznych elementów sceny
  513.  
  514. glutMouseFunc(Mouse);
  515. // Ustala funkcj? zwrotn? odpowiedzialn? za badanie stanu myszy
  516.  
  517. glutMotionFunc(Motion);
  518. // Ustala funkcj? zwrotn? odpowiedzialn? za badanie ruchu myszy
  519.  
  520. glutMainLoop();
  521. // Funkcja uruchamia szkielet biblioteki GLUT
  522.  
  523. }
  524.  
  525.  
  526.  
  527. /*************************************************************************************/
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!