1. /*
2.  * Laboratorium Grafiki Komputerowej * Pierwszy program wykorzystujący OpenGL'a*/
3.                                                                                
4. #include<stdio.h>                                                       /* System */
5. #include<stdlib.h>                                                                                     
6. #include <GL/freeglut.h>                                        /* Biblioteka GLUT */
7.  
8. void DrawScene(void);                                           /* Funkcja do rysowania *//* Funkcja do rysowania */
9. void InitOpenGL(void);                                          /* Funkcja do inicjacji OpenGLa */
10. void ReshapeWindow(int width, int height);      /* Funkcja wywoływana w momentach zmiany rozmiarów okna */
11. void Kwadrat(GLfloat,GLfloat,GLfloat, int);                                                                                    
12. int mainWindow;                                                         /* Globalny identyfikator głównego okna programu */
13. int n;
14. GLfloat bok;
15. GLfloat wierzcholek0;
16. /* Funkcja main */
17. int main(int argc, char **argv)
18. {
19.         glutInit(&argc, argv);                                                                  // Inicjujemy bibliotekę GLUT
20.     glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);                        // Inicjujemy: format koloru, jeden bufor ramki
21.     glutInitWindowSize(500, 500);                                                       // Ustawiamy początkowe wymiary okna
22.         glutInitWindowPosition(0,0);                                                    // Ustawiamy pozycję okna - lewy górny naroznik
23.         do
24.         {      
25.                 printf("Ilosc Iteracji (n>=0): ");scanf("%d",&n);
26.                 if(n<0)
27.                 {
28.                         printf("\nPodales zla liczbe iteracji. Wprowadz jeszcze raz.\n");
29.                 }
30.         }while(n<0);
31.         do
32.         {
33.                 printf("Dlugosc boku <1,600>(rozmiar okna 600x600): ");
34.                 scanf("%f",&bok);      
35.                 if(n<1)
36.                 {
37.                         printf("\nZla wartosc. Wprowadz jeszcze raz.\n");
38.                 }
39.         }while(bok<=0);
40.         printf("\nIlosc iteracji bedzie wynosila: %d",n);      
41.         printf("\nDlugość boku: %f\n",bok);
42.         bok/=3;
43.         wierzcholek0=(-1*bok)/2;
44.         system("pause");
45.         mainWindow = glutCreateWindow("DYWAN SIERPINSKIEGO_V7");        // Tworzymy główne okno programu TYTUŁ
46.         if(mainWindow == 0)                                                                             // Sprawdzamy powodzenie operacji
47.         {
48.                 puts("Nie mozna stworzyc okna!!!\nWyjscie z programu.\n");
49.                 exit(-1);
50.         }
51.         glutSetWindow(mainWindow);                                                              // Czynimy aktywnym okno główne programu
52.         glutDisplayFunc(DrawScene);                                             // Tutaj rejestrujemy funkcje narzędziowe - tzw. callbacks
53.         glutReshapeFunc(ReshapeWindow);                                 // Tutaj rejestrujemy funkcje narzędziowe - tzw. callbacks
54.         InitOpenGL();                   // ustawienia początkowe
55.         glutMainLoop();         // Wejście do pętli programu
56.         return(0);
57. }
58.  
59. /* Ta funkcja służy do wstępnej konfiguracji OpenGLa. * Zanim coś narysujemy musimy wywołać tę funkcję. */
60. void InitOpenGL(void)
61. {
62.         glClearColor(0.0f, 0.0f, 0.0f, 1.0f);// Usawiamy domyślny, czarny kolor tła okna - bufor ramki malujemy na czarno
63. }
64.  
65. /* Tę funkcję wywołuje system w momencie gdy uytkownik zmieni myszą * rozmiar głownego okna. jej zadaniem jest zachowanie propocji wymiarów * rysowanych obiektów niezależnie od wymiarów okna. */
66. void ReshapeWindow(int width, int height)
67. {
68.         int aspectRatio;                                                        // = width / height
69.         if(height == 0)                                                         // Na wypadek dzielenia przez 0
70.         {
71.                 height = 1;
72.         }
73.         aspectRatio = width / height;                                           // Wyliczamy współczynnik proporcji
74.         glViewport(0, 0, width, height);                                        // Ustawiamy wielkości okna okna urządzenia w zakresie // od 0,0 do wysokość, szerokość
75.     glMatrixMode(GL_PROJECTION);                                                // Ustawiamy układ współrzędnych obserwatora
76.         glLoadIdentity();                                                                       // Resetujemy macierz projkecji
77.     if(width <= height)                                                 // Korekta  
78.         {
79.                 glOrtho(-100.0, 100.0, -100.0/aspectRatio, 100.0/aspectRatio, 1.0, -1.0);      
80.         }      
81.         else
82.         {
83.                 glOrtho(-100.0*aspectRatio, 100.0*aspectRatio, -100.0, 100.0, 1.0, -1.0);
84.         }
85.         glMatrixMode(GL_MODELVIEW);// Ustawiamy macierz modelu
86.     glLoadIdentity();// Resetujemy macierz modelu
87. }
88.  
89. /* W tej funkcji określamy to co ma byc narysowane na ekranie.* Jest wywoływana zawsze wtedy, gdy trzeba przerysować ekran - bufor ramki.*/
90. void DrawScene(void)
91. {
92.         glClear(GL_COLOR_BUFFER_BIT);   // Czyścimy okno aktualnym (domyślnym) kolorem
93.         Kwadrat(wierzcholek0,wierzcholek0,bok, 1);
94.         glFlush();                                              // Komenda wykonania poleceń rysujących
95. }
96. void Kwadrat(GLfloat x1,GLfloat y1,GLfloat dl,int iter)
97. {
98.         if(iter>n)
99.         {
100.                 GLfloat x2 = x1+dl;
101.                 GLfloat y2 = y1+dl;
102.                 glBegin(GL_POLYGON);                    // Tworzenie prymitywów graficznych zawsze ograniczamy funkcjami glBegin i glEnd
103.                 glColor3ub( 150, 255, 100);// Ustawiamy bieżący kolor rysowania na zielony
104.                 glVertex2f(x1, y1);     // Dwa końce pierwszego odcinka
105.                 glVertex2f(x2,y1);//wierzchołek
106.                 glVertex2f(x2, y2);
107.                 glVertex2f(x1,y2);//wierzchołek        
108.  
109.                 glEnd();
110.         }
111.         else
112.         {
113.                 dl/=3;
114.                 iter++;
115.                 Kwadrat(x1,                     y1,                     dl,iter);
116.                 Kwadrat(x1+dl,          y1,                     dl,iter);
117.                 Kwadrat(x1+2*dl,        y1,                     dl,iter);
118.                 Kwadrat(x1,                     y1+dl,          dl,iter);
119.                 Kwadrat(x1+2*dl,        y1+dl,          dl,iter);
120.                 Kwadrat(x1,                     y1+2*dl,        dl,iter);
121.                 Kwadrat(x1+dl,          y1+2*dl,        dl,iter);
122.                 Kwadrat(x1+2*dl,        y1+2*dl,                dl,iter);      
123.         }
124. }