API tools faq
paste
Guest User

Untitled

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