API tools faq
paste
Advertisement
Guest User

Untitled

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