daily pastebin goal
23%
SHARE
TWEET

Untitled

a guest Jan 17th, 2019 71 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. //////////////////////////////////////////////////////////////////////////////////////////
  2. //
  3. // Program wyswietlajacy szescian w rzucie perspektywicznym. Dlugosc boku szescianu
  4. // moze byc interaktywnie zmieniana za pomoca klwiszy '+' i '-'.
  5. //
  6. //////////////////////////////////////////////////////////////////////////////////////////
  7. #include <GL/glut.h>
  8. #include <math.h>
  9. #include <stdio.h>
  10.  
  11. // Definicja stalych
  12. #define DLUGOSC_BOKU            5.0
  13. #define OBSERWATOR_FOV_Y        30.0  
  14. #define PI                      3.1416
  15. #define LPOZ_MAX            100
  16. #define LPOZ_MIN            3
  17. #define LPION_MAX           100
  18. #define LPION_MIN           3
  19. #define R_MAX               10.0
  20. #define WYS_MAX             5.0
  21. #define KROK_FLOAT          0.1
  22. #define X_OFFSET_SWIATLO    10
  23. #define Y_OFFSET_SWIATLO    0
  24. #define X_OFFSET_MAT        10
  25. #define Y_OFFSET_MAT        100
  26. #define X_OFFSET_OBIEKT     10
  27. #define Y_OFFSET_OBIEKT     245
  28. #define ID_MENU_SWIATLA     0
  29. #define ID_MENU_MATERIALU   1
  30. #define LPOZ_MENU_SWIATLA   10
  31. #define LPOZ_MENU_MATERIALU 5
  32. #define M_PI                3.14159
  33.  
  34. // Zmienne globalne
  35. double  bok = DLUGOSC_BOKU; // Dlugosc boku szescianu
  36. int     szerokoscOkna = 800;
  37. int     wysokoscOkna = 600;
  38. float OBSERWATOR_ODLEGLOSC = 100.0;
  39. float OBSERWATOR_OBROT_X = 20.0;
  40. float OBSERWATOR_OBROT_Y = 20.0;
  41. float OBSERWATOR_OBROT_Z = 0.0;
  42. float odlmax = 60.0;
  43. float odlmin = 5.0;
  44. float r1 = 3.0;
  45. float r2 = 3.0;
  46. float h = 4.0;
  47. float i, y, x, z;
  48. float angle = 0;
  49. float r = 10; //Wewnetrzny
  50. float H = 2.598;
  51. float R = 10 + 2.598; //R + wysokosc trojkata rownobocznego
  52. float R1 = 11.5;
  53. float R2 = 13;
  54. GLfloat ringInnerRadius = 15.0;
  55. GLfloat ringInnerRadius1;
  56. GLfloat bokromb = 5;
  57. GLfloat liczbaPodzialow = 4.0;
  58. GLfloat dAlpha = 90.0;
  59. float N = 20;
  60. GLfloat kat1 = 30;
  61. int obrot = 0, promRef = 1, kat0X = 0;
  62. int predKat = 1;
  63. int trybRys = 1;
  64. int trybCien = 1;
  65. int light1, light2, material = 1;
  66. GLUquadric* orbita;
  67. GLfloat norm1[3], norm2[3], norm3[3];
  68. int wektory = 1;
  69. // Tablica parametrow swiatla
  70.  
  71. GLfloat swiatlo[10][4] = {  //reflektor bialy
  72.     { 1.0, 1.0, 1.0, 1.0 },  // [0] otoczenie
  73.     { 1.0, 1.0, 1.0, 1.0 },  // [1] rozproszenie
  74.     { 1.0, 1.0, 1.0, 1.0 },  // [2] lustrzane
  75.     { 0.0, 0.0, 0.0, 1.0 },  // [3] polozenie
  76.     { -1.0, 0.0, 0.0, 0.0 }, // [4] kierunek swiecenia
  77.     { 0.0, 0.0, 0.0, 0.0 },  // [5] tlumienie katowe swiatla
  78.     { 30.0, 0.0, 0.0, 0.0 },// [6] kat odciecia swiatla
  79.     { 1.0, 0.0, 0.0, 0.0 },  // [7] stale tlumienie
  80.     { 0.0, 0.0, 0.0, 0.0 },  // [8] tlumienie liniowe
  81.     { 0.0, 0.0, 0.0, 0.0 } }; // [9] tlumienie kwadratowe
  82.  
  83. GLfloat swiatlo1[10][4] = { //kierunkowe zielone
  84.     {0.0, 1.0, 0.0, 0.7},  // [0] otoczenie
  85.     {0.3, 0.3, 0.3, 0.7},  // [1] rozproszenie
  86.     {1.0, 1.0, 1.0, 1.0},  // [2] lustrzane
  87.     {10.0, 10.0, 10.0, 0.0},  // [3] polozenie
  88.     { 10.0, -10.0, -10.0, 0.0 }, // [4] kierunek swiecenia
  89.     { 0.0, 0.0, 0.0, 0.0 },  // [5] tlumienie katowe swiatla
  90.     { 180.0, 0.0, 0.0, 0.0 },// [6] kat odciecia swiatla
  91.     { 1.0, 0.0, 0.0, 0.0 },  // [7] stale tlumienie
  92.     { 0.0, 0.0, 0.0, 0.0 },  // [8] tlumienie liniowe
  93.     { 0.0, 0.0, 0.0, 0.0 } }; // [9] tlumienie kwadratowe
  94.  
  95. GLfloat material1[6][4] = { //fioletowy blyszczcacy
  96.     { 0.35, 0.0, 0.45, 1.000000 },  // [0] wspolczynnik odbicia swiatla otoczenia
  97.     { 0.6, 0.1, 0.6, 1.000000 },  // [1] wspolczynnik odbicia swiatla rozproszonego
  98.     { 1.0, 0.9, 1.0, 1.000000 },  // [2] wspolczynnik odbicia swiatla lustrzanego
  99.     { 75, 75, 75, 1.0 },  // [3] polysk
  100.     { 0.0, 0.0, 0.0, 0.0 } }; // [4] kolor swiatla emitowanego
  101.  
  102. GLfloat material2[6][4] = { //zółty matowy
  103.     { 1.0, 1.0, 0.0, 1.000000 },  // [0] wspolczynnik odbicia swiatla otoczenia
  104.     { 0.5, 0.5, 0.0, 1.000000 },  // [1] wspolczynnik odbicia swiatla rozproszonego
  105.     {0.0, 0.0, 0.0, 0.0  },  // [2] wspolczynnik odbicia swiatla lustrzanego
  106.     { 0.0, 0.0, 0.0, 0.0 },  // [3] polysk
  107.     { 0.0, 0.0, 0.0, 0.0 } }; // [4] kolor swiatla emitowanego
  108.  
  109. GLfloat material3[6][4] = { //mosiądz
  110. { 0.329412, 0.223529, 0.027451, 1.0},  // [0] wspolczynnik odbicia swiatla otoczenia
  111. { 0.780392, 0.568627, 0.113725, 1.0 },  // [1] wspolczynnik odbicia swiatlarozproszonego
  112. { 0.992157, 0.941176, 0.807843, 1.0 },  // [2] wspolczynnik odbicia swiatla lustrzanego
  113. { 52.2, 52.2, 52.2, 1.0 },  // [3] polysk
  114. { 0.0, 0.0, 0.0, 0.0 } }; // [4] kolor swiatla emitowanego
  115.  
  116. double DEG2RAD(double deg) {
  117.     return deg * M_PI / 180.0;
  118. }
  119.                               // Prototypy funkcji
  120. void RysujPierscien(void);
  121. void UstawParametryWidoku(int szer, int wys);
  122. void WyswietlObraz(void);
  123. void ObslugaKlawiatury(unsigned char klawisz, int x, int y);
  124. void WektNorm(GLfloat* p1, GLfloat* p2, GLfloat* p3, GLfloat* out, char flip, GLfloat* norm);
  125. void WlaczWektory(void);
  126. void WlaczOswietlenie(void);
  127. void RysujTekstRastrowy(void *font, char *tekst);
  128. void RysujNakladke(int N, int r);
  129.  
  130. //////////////////////////////////////////////////////////////////////////////////////////
  131. // Funkcja rysujaca pierscien
  132. void RysujPierscien() {
  133.  
  134.     int i;
  135.     GLfloat ringHeight = bokromb * sin(DEG2RAD(kat1 / 2));
  136.     GLfloat ringWidth = bokromb * cos(DEG2RAD(kat1 / 2));
  137.     // Dolna podstawa
  138.     glColor3f(1.0, 0.0, 0.5);
  139.     glBegin(GL_QUADS);
  140.     glNormal3f(0.0, -1.0, 0.0);
  141.  
  142.     for (i = 0; i <= liczbaPodzialow; i++) {
  143.  
  144.         glVertex3f(ringInnerRadius * cos(DEG2RAD(i * dAlpha)), 0.0, ringInnerRadius * sin(DEG2RAD(i * dAlpha)));
  145.         glVertex3f((ringInnerRadius + ringWidth) * cos(DEG2RAD(i * dAlpha)), ringHeight, (ringInnerRadius + ringWidth) * sin(DEG2RAD(i * dAlpha)));
  146.         glVertex3f((ringInnerRadius + ringWidth) * cos(DEG2RAD((i + 1) * dAlpha)), ringHeight, (ringInnerRadius + ringWidth) * sin(DEG2RAD((i + 1) * dAlpha)));
  147.         glVertex3f(ringInnerRadius * cos(DEG2RAD((i + 1) * dAlpha)), 0.0, ringInnerRadius * sin(DEG2RAD((i + 1) * dAlpha)));
  148.  
  149.     }
  150.  
  151.     glEnd();
  152.  
  153.  
  154.     // Gorna podstawa
  155.     glColor3f(0.0, 1.0, 0.6);
  156.     glBegin(GL_QUADS);
  157.     glNormal3f(0.0, 1.0, 0.0);
  158.  
  159.     for (i = 0; i <= liczbaPodzialow; i++) {
  160.  
  161.         glVertex3f(ringInnerRadius * cos(DEG2RAD(i * dAlpha)), 0, ringInnerRadius * sin(DEG2RAD(i * dAlpha)));
  162.         glVertex3f((ringInnerRadius + ringWidth) * cos(DEG2RAD(i * dAlpha)), -ringHeight, (ringInnerRadius + ringWidth) * sin(DEG2RAD(i * dAlpha)));
  163.         glVertex3f((ringInnerRadius + ringWidth) * cos(DEG2RAD((i + 1) * dAlpha)), -ringHeight, (ringInnerRadius + ringWidth) * sin(DEG2RAD((i + 1) * dAlpha)));
  164.         glVertex3f(ringInnerRadius * cos(DEG2RAD((i + 1) * dAlpha)), 0, ringInnerRadius * sin(DEG2RAD((i + 1) * dAlpha)));
  165.  
  166.     }
  167.  
  168.     glEnd();
  169.  
  170.     //
  171.     ringInnerRadius1 = ringInnerRadius + ringWidth;
  172.     //LD
  173.     glColor3f(1.0, 1.0, 0.0);
  174.     glBegin(GL_QUADS);
  175.  
  176.     for (i = 0; i <= liczbaPodzialow; i++) {
  177.         glColor3f(0, 1, 0);
  178.         glVertex3f(ringInnerRadius1 * cos(DEG2RAD(i * dAlpha)), -ringHeight, ringInnerRadius1 * sin(DEG2RAD(i * dAlpha)));
  179.  
  180.         glVertex3f((ringInnerRadius1 + ringWidth) * cos(DEG2RAD(i * dAlpha)), 0, (ringInnerRadius1 + ringWidth) * sin(DEG2RAD(i * dAlpha)));
  181.  
  182.         glVertex3f((ringInnerRadius1 + ringWidth) * cos(DEG2RAD((i + 1) * dAlpha)), 0, (ringInnerRadius1 + ringWidth) * sin(DEG2RAD((i + 1) * dAlpha)));
  183.         glVertex3f(ringInnerRadius1 * cos(DEG2RAD((i + 1) * dAlpha)), -ringHeight, ringInnerRadius1 * sin(DEG2RAD((i + 1) * dAlpha)));
  184.  
  185.     }
  186.  
  187.     glEnd();
  188.  
  189.     //LG
  190.     glColor3f(1.0, 0.5, 0.0);
  191.     glBegin(GL_QUADS);
  192.  
  193.     for (i = 0; i <= liczbaPodzialow; i++) {
  194.  
  195.         glVertex3f(ringInnerRadius1 * cos(DEG2RAD(i * dAlpha)), ringHeight, ringInnerRadius1 * sin(DEG2RAD(i * dAlpha)));
  196.         glVertex3f((ringInnerRadius1 + ringWidth) * cos(DEG2RAD(i * dAlpha)), 0, (ringInnerRadius1 + ringWidth) * sin(DEG2RAD(i * dAlpha)));
  197.         glVertex3f((ringInnerRadius1 + ringWidth) * cos(DEG2RAD((i + 1) * dAlpha)), 0, (ringInnerRadius1 + ringWidth) * sin(DEG2RAD((i + 1) * dAlpha)));
  198.         glVertex3f(ringInnerRadius1 * cos(DEG2RAD((i + 1) * dAlpha)), ringHeight, ringInnerRadius1 * sin(DEG2RAD((i + 1) * dAlpha)));
  199.  
  200.     }
  201.  
  202.     glEnd();
  203.  
  204.  
  205.  
  206. }
  207. ////////////////////////////////////////////////////
  208. //WEKTORY NORMALNE
  209. void WlaczWektory(void) {
  210.     glBegin(GL_LINES);
  211.     glColor3f(0, 0, 1);
  212.     for (angle = 0.0; angle <= (2.0*PI + 0.01); angle += (2 * PI / N))
  213.     {
  214.         GLfloat p1[] = { r*cos(angle), 0, r*sin(angle) };
  215.         GLfloat p2[] = { r*cos(angle + 2 * PI / N), 0, r*sin(angle + 2 * PI / N) };
  216.         GLfloat p3[] = { R2*cos(angle + 2 * PI / N), 0, R2*sin(angle + 2 * PI / N) };
  217.         GLfloat out[] = { 0, 0, 0 };
  218.  
  219.         WektNorm(p1, p2, p3, out, 'b', norm1);
  220.         if (wektory == 1) {
  221.             glVertex3f(r*cos(angle), 0, r*sin(angle));
  222.             glVertex3f(r*cos(angle) + out[0], 0 + out[1], r*sin(angle) + out[2]);
  223.         }
  224.     }
  225.     glEnd();
  226.     glColor3f(0, 1, 0);
  227.     glBegin(GL_LINES);
  228.     for (angle = 0.0; angle <= (2.0*PI + 0.01); angle += (2 * PI / N))
  229.     {
  230.         GLfloat p1[] = { R1*cos(angle), H, R1*sin(angle) };
  231.         GLfloat p2[] = { R1*cos(angle + 2 * PI / N), H, R1*sin(angle + 2 * PI / N) };
  232.         GLfloat p3[] = { r*cos(angle + 2 * PI / N), 0, r*sin(angle + 2 * PI / N) };
  233.         GLfloat out[] = { 0, 0, 0 };
  234.  
  235.         WektNorm(p1, p2, p3, out, 'b', norm2);
  236.         if (wektory == 1) {
  237.             glVertex3f(R1*cos(angle), H, R1*sin(angle));
  238.             glVertex3f(R1*cos(angle) + out[0], H + out[1], R1*sin(angle) + out[2]);
  239.         }
  240.     }
  241.     glEnd();
  242.  
  243.     glColor3f(1, 0, 0);
  244.     glBegin(GL_LINES);
  245.     for (angle = 0.0; angle <= (2.0*PI + 0.01); angle += (2 * PI / N))
  246.     {
  247.         GLfloat p1[] = { R2*cos(angle), 0, R2*sin(angle) };
  248.         GLfloat p2[] = { R2*cos(angle + 2 * PI / N), 0, R2*sin(angle + 2 * PI / N) };
  249.         GLfloat p3[] = { R1*cos(angle + 2 * PI / N), H, R1*sin(angle + 2 * PI / N) };
  250.         GLfloat out[] = { 0, 0, 0 };
  251.  
  252.         WektNorm(p1, p2, p3, out, 'b', norm3);
  253.         if (wektory == 1) {
  254.             glVertex3f(R2*cos(angle), 0, R2*sin(angle));
  255.             glVertex3f(R2*cos(angle) + out[0], 0 + out[1], R2*sin(angle) + out[2]);
  256.         }
  257.     }
  258.     glEnd();
  259. }
  260.  
  261. void WektNorm(GLfloat* p1, GLfloat* p2, GLfloat* p3, GLfloat* out, char flip, GLfloat* norm)
  262. {
  263.     double l;
  264.  
  265.     GLfloat a[3], b[3];
  266.  
  267.     a[0] = p3[0] - p1[0];
  268.     a[1] = p3[1] - p1[1];
  269.     a[2] = p3[2] - p1[2];
  270.  
  271.     b[0] = p2[0] - p1[0];
  272.     b[1] = p2[1] - p1[1];
  273.     b[2] = p2[2] - p1[2];
  274.  
  275.     out[0] = (a[1] * b[2]) - (a[2] * b[1]);
  276.     out[1] = (a[2] * b[0]) - (a[0] * b[2]);
  277.     out[2] = (a[0] * b[1]) - (a[1] * b[0]);
  278.  
  279.     l = sqrt(out[0] * out[0] + out[1] * out[1] + out[2] * out[2]);
  280.     out[0] /= l;
  281.     out[1] /= l;
  282.     out[2] /= l;
  283.  
  284.     if (flip == 'a')
  285.     {
  286.         out[0] = -out[0];
  287.         out[1] = -out[1];
  288.         out[2] = -out[2];
  289.     }
  290.  
  291.     norm[0] = out[0];
  292.     norm[1] = out[1];
  293.     norm[2] = out[2];
  294. }
  295.  
  296. void WlaczOswietlenie(void) {
  297.     // Odblokowanie oswietlenia
  298.     glEnable(GL_LIGHTING);
  299.  
  300.     if (light1 == 1) glEnable(GL_LIGHT1);
  301.     else glDisable(GL_LIGHT1);
  302.  
  303.     if (light2 == 1) glEnable(GL_LIGHT2);
  304.     else glDisable(GL_LIGHT2);
  305.  
  306.     // Inicjowanie zrodla swiatla
  307.     glPushMatrix();
  308.     orbita = gluNewQuadric();
  309.     gluQuadricDrawStyle(orbita, GLU_LINE);
  310.     glRotatef(90.0, 1, 0, 0);
  311.     glRotatef(kat0X, 1, 0, 0);
  312.     gluDisk(orbita, promRef, promRef, 100, 100);
  313.     glRotatef(-90.0, 1, 0, 0);
  314.     glColor3f(1, 1, 1);
  315.     glRotatef(obrot, 0, 1, 0);
  316.     glTranslatef(promRef, 0, 0);
  317.     glutSolidSphere(0.25, 50, 50);
  318.     obrot += predKat;
  319.  
  320.     // Inicjowanie zrodla swiatla
  321.     glLightfv(GL_LIGHT1, GL_AMBIENT, swiatlo[0]);
  322.     glLightfv(GL_LIGHT1, GL_DIFFUSE, swiatlo[1]);
  323.     glLightfv(GL_LIGHT1, GL_SPECULAR, swiatlo[2]);
  324.     glLightfv(GL_LIGHT1, GL_POSITION, swiatlo[3]);
  325.     glLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, swiatlo[4]);
  326.     glLightf(GL_LIGHT1, GL_SPOT_EXPONENT, swiatlo[5][0]);
  327.     glLightf(GL_LIGHT1, GL_SPOT_CUTOFF, swiatlo[6][0]);
  328.     glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, swiatlo[7][0]);
  329.     glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, swiatlo[8][0]);
  330.     glLightf(GL_LIGHT1, GL_QUADRATIC_ATTENUATION, swiatlo[9][0]);
  331.     glPopMatrix();
  332.  
  333.  
  334.     glLightfv(GL_LIGHT2, GL_AMBIENT, swiatlo1[0]);
  335.     glLightfv(GL_LIGHT2, GL_DIFFUSE, swiatlo1[1]);
  336.     glLightfv(GL_LIGHT2, GL_SPECULAR, swiatlo1[2]);
  337.     glLightfv(GL_LIGHT2, GL_POSITION, swiatlo1[3]);
  338.     glLightfv(GL_LIGHT2, GL_SPOT_DIRECTION, swiatlo1[4]);
  339.     glLightf(GL_LIGHT2, GL_SPOT_EXPONENT, swiatlo1[5][0]);
  340.     glLightf(GL_LIGHT2, GL_SPOT_CUTOFF, swiatlo1[6][0]);
  341.     glLightf(GL_LIGHT2, GL_CONSTANT_ATTENUATION, swiatlo1[7][0]);
  342.     glLightf(GL_LIGHT2, GL_LINEAR_ATTENUATION, swiatlo1[8][0]);
  343.     glLightf(GL_LIGHT2, GL_QUADRATIC_ATTENUATION, swiatlo1[9][0]);
  344.  
  345.  
  346. }
  347.  
  348. ////////////////////////////////////
  349.  
  350. void DefiniujMaterial(void)
  351. {
  352.     if (material == 1) {
  353.         glMaterialfv(GL_FRONT, GL_AMBIENT, material1[0]);
  354.         glMaterialfv(GL_FRONT, GL_DIFFUSE, material1[1]);
  355.         glMaterialfv(GL_FRONT, GL_SPECULAR, material1[2]);
  356.         glMaterialfv(GL_FRONT, GL_SHININESS, material1[3]);
  357.         glMaterialfv(GL_FRONT, GL_EMISSION, material1[4]);
  358.     }
  359.  
  360.     if (material == 2) {
  361.         glMaterialfv(GL_FRONT, GL_AMBIENT, material2[0]);
  362.         glMaterialfv(GL_FRONT, GL_DIFFUSE, material2[1]);
  363.         glMaterialfv(GL_FRONT, GL_SPECULAR, material2[2]);
  364.         glMaterialfv(GL_FRONT, GL_SHININESS, material2[3]);
  365.         glMaterialfv(GL_FRONT, GL_EMISSION, material2[4]);
  366.  
  367.     }
  368.  
  369.     if (material == 3) {
  370.         glMaterialfv(GL_FRONT, GL_AMBIENT, material3[0]);
  371.         glMaterialfv(GL_FRONT, GL_DIFFUSE, material3[1]);
  372.         glMaterialfv(GL_FRONT, GL_SPECULAR, material3[2]);
  373.         glMaterialfv(GL_FRONT, GL_SHININESS, material3[3]);
  374.         glMaterialfv(GL_FRONT, GL_EMISSION, material3[4]);
  375.     }
  376. }
  377. ///////////////////////////////////////
  378. void RysujTekstRastrowy(void *font, char *tekst)
  379. {
  380.     int i;
  381.  
  382.     for (i = 0; i < (int)strlen(tekst); i++)
  383.         glutBitmapCharacter(font, tekst[i]);
  384. }
  385.  
  386. void RysujNakladke(int N, int r)
  387. {
  388.     char buf[255];
  389.     // Zmiana typu rzutu z perspektywicznego na ortogonalny
  390.     glMatrixMode(GL_PROJECTION);
  391.     glPushMatrix();
  392.     glLoadIdentity();
  393.     glOrtho(0.0, szerokoscOkna, 0.0, wysokoscOkna, -100.0, 100.0);
  394.     // Modelowanie sceny 2D (zawartosci nakladki)
  395.     glMatrixMode(GL_MODELVIEW);
  396.     glPushMatrix();
  397.     glLoadIdentity();
  398.     // Zablokowanie oswietlenia (mialoby ono wplyw na kolor tekstu)
  399.     glDisable(GL_LIGHTING);
  400.     // Okreslenie koloru tekstu
  401.     glColor3f(1.0, 1.0, 1.0);
  402.     sprintf_s(buf, "Pierscien:");
  403.     glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT-65);
  404.     RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);
  405.  
  406.     sprintf_s(buf, "Swiatlo:");
  407.     glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT - 80);
  408.     RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);
  409.  
  410.     sprintf_s(buf, " - Swiatlo pierwsze (klawisz v) - %d", light1);
  411.     glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT - 95);
  412.     RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);
  413.  
  414.     sprintf_s(buf, "    - Promien orbity (klawisze t, T) - %d", promRef);
  415.     glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT - 110);
  416.     RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);
  417.  
  418.     sprintf_s(buf, "    - Predkosc swiatla 1 (klawisze u, U) - %d", predKat);
  419.     glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT - 125);
  420.     RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);
  421.  
  422.     sprintf_s(buf, "    - Kat nachylenia orbity (klawisze y, Y) - %d", kat0X);
  423.     glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT - 140);
  424.     RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);
  425.  
  426.     sprintf_s(buf, " - Swiatlo drugie  (klawisz b) - %d", light2);
  427.     glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT - 155);
  428.     RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);
  429.  
  430.     sprintf_s(buf, "Material - %d (klawisze 3-5)", material);
  431.     glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT - 175);
  432.     RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);
  433.  
  434.     sprintf_s(buf, "Tryb rysowania bryly (klawisz c): %d", trybRys);
  435.     glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT - 195);
  436.     RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);
  437.  
  438.     sprintf_s(buf, "Tryb cieniowania bryly (klawisz f): %d", trybCien);
  439.     glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT - 215);
  440.     RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);
  441.  
  442.     sprintf_s(buf, "Zmiana podzialow bryly zwieksz/zmniejsz =/+");
  443.     glRasterPos2i(X_OFFSET_OBIEKT, Y_OFFSET_OBIEKT - 235);
  444.     RysujTekstRastrowy(GLUT_BITMAP_8_BY_13, buf);
  445.  
  446.  
  447.     // Przywrocenie macierzy sprzed wywolania funkcji
  448.     glMatrixMode(GL_PROJECTION);
  449.     glPopMatrix();
  450.     glMatrixMode(GL_MODELVIEW);
  451.     glPopMatrix();
  452.  
  453.     // Odblokowanie oswietlenia
  454.     glEnable(GL_LIGHTING);
  455. }
  456.  
  457. //////////////////////////////////////////////////////////////////////////////////////////
  458. // Funkcja ustawiajaca parametry rzutu perspektywicznego i rozmiary viewportu. Powinna
  459. // być wywolywana kazdorazowo po zmianie rozmiarow okna programu.
  460. void UstawParametryWidoku(int szer, int wys)
  461. {
  462.     // Zapamietanie wielkosci widoku
  463.     szerokoscOkna = szer;
  464.     wysokoscOkna = wys;
  465.  
  466.     // Ustawienie parametrow viewportu
  467.     glViewport(0, 0, szerokoscOkna, wysokoscOkna);
  468.  
  469.     // Przejscie w tryb modyfikacji macierzy rzutowania
  470.     glMatrixMode(GL_PROJECTION);
  471.     glLoadIdentity();
  472.     gluPerspective(OBSERWATOR_FOV_Y, (float)szerokoscOkna / (float)wysokoscOkna, 1.0, 1000.0);
  473. }
  474.  
  475.  
  476. //////////////////////////////////////////////////////////////////////////////////////////
  477. // Funkcja wyswietlajaca pojedyncza klatke animacji
  478. void WyswietlObraz(void)
  479. {
  480.     // Wyczyszczenie bufora koloru i bufora glebokosci
  481.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  482.  
  483.     // Przejscie w tryb modyfikacji macierzy przeksztalcen geometrycznych
  484.     glMatrixMode(GL_MODELVIEW);
  485.  
  486.     // Zastapienie aktywnej macierzy macierza jednostkowa
  487.     glLoadIdentity();
  488.  
  489.     // Ustalenie polozenia obserwatora
  490.     glTranslatef(0, 0, -OBSERWATOR_ODLEGLOSC);
  491.     glRotatef(OBSERWATOR_OBROT_X, 1, 0, 0);
  492.     glRotatef(OBSERWATOR_OBROT_Y, 0, 1, 0);
  493.     glRotatef(OBSERWATOR_OBROT_Z, 0, 0, 1);
  494.  
  495.     //Narysowanie wektorow
  496.    
  497.     //Wlaczenie oswietlenia
  498.     WlaczOswietlenie();
  499.     //Wlaczenie materialow
  500.     DefiniujMaterial();
  501.     // Narysowanie szescianu
  502.     RysujPierscien();
  503.  
  504.     //Rysowanie menu
  505.     RysujNakladke(N, r);
  506.  
  507.     // Przelaczenie buforow ramki
  508.     glutSwapBuffers();
  509. }
  510.  
  511.  
  512. //////////////////////////////////////////////////////////////////////////////////////////
  513. // Funkcja obslugi klawiatury
  514. void ObslugaKlawiatury(unsigned char klawisz, int x, int y)
  515. {
  516.     if (klawisz == '+')
  517.         bok *= 2.0;
  518.     else if (klawisz == '-')
  519.         bok /= 2.0;
  520.     else if (klawisz == 27)
  521.         exit(0);
  522.     else if (klawisz == '1')
  523.         OBSERWATOR_ODLEGLOSC = (OBSERWATOR_ODLEGLOSC > odlmin) ? OBSERWATOR_ODLEGLOSC - 1.0 : OBSERWATOR_ODLEGLOSC;
  524.     else if (klawisz == '2')
  525.         OBSERWATOR_ODLEGLOSC = (OBSERWATOR_ODLEGLOSC < odlmax) ? OBSERWATOR_ODLEGLOSC + 1.0 : OBSERWATOR_ODLEGLOSC;
  526.     else if (klawisz == 'w')
  527.         OBSERWATOR_OBROT_X = OBSERWATOR_OBROT_X + 1.0;
  528.     else if (klawisz == 's')
  529.         OBSERWATOR_OBROT_X = OBSERWATOR_OBROT_X - 1.0;
  530.     else if (klawisz == 'a')
  531.         OBSERWATOR_OBROT_Y = OBSERWATOR_OBROT_Y + 1.0;
  532.     else if (klawisz == 'd')
  533.         OBSERWATOR_OBROT_Y = OBSERWATOR_OBROT_Y - 1.0;
  534.     else if (klawisz == 'q')
  535.         OBSERWATOR_OBROT_Z = OBSERWATOR_OBROT_Z + 1.0;
  536.     else if (klawisz == 'e')
  537.         OBSERWATOR_OBROT_Z = OBSERWATOR_OBROT_Z - 1.0;
  538.     else if (klawisz == 'z')
  539.         N = (N >= 6) ? N - 2.0 : N;
  540.     else if (klawisz == 'x')
  541.         N = (N <= 62) ? N + 2.0 : N;
  542.     else if (klawisz == 'c') {
  543.         trybRys = (trybRys == 1) ? 0 : 1;
  544.         if (trybRys == 1) glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  545.         else glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  546.     }
  547.     else if (klawisz == 'v')
  548.         light1 = light1 == 0 ? 1 : 0;
  549.     else if (klawisz == 'b')
  550.         light2 = light2 == 0 ? 1 : 0;
  551.     else if (klawisz == '3')
  552.         material = 1;
  553.     else if (klawisz == '4')
  554.         material = 2;
  555.     else if (klawisz == '5')
  556.         material = 3;
  557.     else if (klawisz == 'f') {
  558.         trybCien = trybCien == 0 ? 1 : 0;
  559.         if (trybCien == 0) glShadeModel(GL_SMOOTH);
  560.         else glShadeModel(GL_FLAT);
  561.     }
  562.    
  563.     else if (klawisz == 't')
  564.         promRef = (promRef < 20) ? promRef + 1 : promRef;
  565.     else if (klawisz == 'T')
  566.         promRef = (promRef > 1) ? promRef - 1 : promRef;
  567.     else if (klawisz == 'u')
  568.         predKat = (predKat < 3) ? predKat + 1 : predKat;
  569.     else if (klawisz == 'U')
  570.         predKat = (predKat > 1) ? predKat - 1 : predKat;
  571.     else if (klawisz == 'y')
  572.         kat0X -= 1;
  573.     else if (klawisz == 'Y')
  574.         kat0X += 1;
  575.     else if (klawisz == '+')
  576.     {
  577.         liczbaPodzialow = (liczbaPodzialow > 4) ? liczbaPodzialow - 1 : liczbaPodzialow;
  578.         dAlpha = 360.0 / liczbaPodzialow;
  579.     }
  580.        
  581.  
  582.     else if (klawisz == '=')
  583.     {
  584. liczbaPodzialow = (liczbaPodzialow < 64) ? liczbaPodzialow + 1 : liczbaPodzialow;
  585.         dAlpha = 360.0 / liczbaPodzialow;
  586.     }
  587.        
  588.    
  589.  
  590. }
  591.  
  592. //////////////////////////////////////////////////////////////////////////////////////////
  593. // Glowna funkcja programu
  594. int  main(int argc, char **argv)
  595. {
  596.     // Zainicjowanie biblioteki GLUT
  597.     glutInit(&argc, argv);
  598.  
  599.     // Ustawienie trybu wyswietlania
  600.     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  601.  
  602.     // Ustawienie polozenia dolenego lewego rogu okna
  603.     glutInitWindowPosition(100, 100);
  604.  
  605.     // Ustawienie rozmiarow okna
  606.     glutInitWindowSize(szerokoscOkna, wysokoscOkna);
  607.  
  608.     // Utworzenie okna
  609.     glutCreateWindow("Szescian");
  610.  
  611.     // Odblokowanie bufora glebokosci
  612.     glEnable(GL_DEPTH_TEST);
  613.  
  614.     // Ustawienie wartosci czyszczacej zawartosc bufora glebokosci
  615.     glClearDepth(1000.0);
  616.  
  617.     // Ustawienie koloru czyszczenia bufora ramki
  618.     glClearColor(0.0f, 0.0f, 0.3f, 0.0f);
  619.  
  620.     // Wlaczenie wyswietlania wielokatow w postaci obrysow (przydatne w celach diagnostycznych).
  621.  
  622.     // Zarejestrowanie funkcji (callback) odpowiedzialnej za
  623.     glutDisplayFunc(WyswietlObraz);
  624.  
  625.     // Zarejestrowanie funkcji (callback) wywolywanej za kazdym razem kiedy
  626.     // zmieniane sa rozmiary okna
  627.     glutReshapeFunc(UstawParametryWidoku);
  628.  
  629.     // Zarejestrowanie funkcji wykonywanej gdy okno nie obsluguje
  630.     // zadnych zadan
  631.     glutIdleFunc(WyswietlObraz);
  632.  
  633.     // Zarejestrowanie funkcji obslugi klawiatury
  634.     glutKeyboardFunc(ObslugaKlawiatury);
  635.  
  636.     // Obsluga glownej petli programu (wywolywanie zarejestrowanych callbackow
  637.     // w odpowiedzi na odbierane zdarzenia lub obsluga stanu bezczynnosci)
  638.     glutMainLoop();
  639.  
  640.     return 0;
  641. }
RAW Paste Data
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
 
Top