// Nagłówek standardowych funkcji matematycznych
#include <math.h>

// Dołącz definicje biblioteki Allegro
#include <allegro.h>


// Bitmapa Allegro, na której będziemy rysowali grafikę przed
// pokazaniem jej na ekranie. Dzięki temu grafika w trakcie
// rysowania nie jest widoczna, a jest pokazywana użytkownikowi
// dopiero wówczas, gdy jej rysowanie jest zakończone i jest
// gotowa do wyświetlenia.
//
BITMAP *buffer;



/*
***************************************************************************

Ekran ma wymiary: w poziomie 0..SCREEN_W-1, w pionie 0..SCREEN_H-1, przy czym
poczatek ukladu wspolrzednych znajduje sie w lewym gornym rogu ekranu.

Rysowanie podstawowych obiektow graficznych umozliwiaja nastepujace procedury:

        create_bitmap( szerokość, wysokość ) - tworzy i zwraca bitmapę o określonym rozmiarze

        load_bitmap( ścieżka_pliku, paleta ) - wczytuje bitmapę z dysku (formaty BMP i TGA)
                jako parametr paleta można podać NULL (w trybach 32-bitowego koloru nie korzysta się z palet)

        destroy_bitmap( bitmapa ) - usuwa utworzoną/wczytaną wcześniej bitmapę

        blit( bitmapa_z, bitmapa_do, sx, sy, dx, dy, szerokość, wysokość ) - kopiuje
                fragment bitmapy do innej bitmapy, kopiowany jest fragment, który ma
                lewy górny róg na bitmapie wyjściowej umieszczony w punkcie (sx,sy),
                po kopiowaniu ten róg trafia w punkt (dx,dy) bitmapy docelowej,
                kopiowany jest fragment o podanej szerokości i wysokości

        bitmapa->w              - pozwala odczytać szerokość bitmapy
        bitmapa->h              - pozwala odczytać wysokość bitmapy

        makecol( r, g, b ) - zwraca numer wybranego koloru
                r, g, b - wartości kanału czerwonego, zielonego i niebieskiego
                                  w zakresie 0..255

        clear(bitmapa) - czyści daną bitmapę

        clear_to_color(bitmapa, kolor) - jak wyżej, lecz czyści na określony kolor

        putpixel(bitmapa, x, y, kolor) - zmienia kolor punktu o wspolrzędnych (x,y).

        line(bitmapa, x1, y1, x2, y2, kolor) - rysuje odcinek między punktami (x1,y1) a (x2,y2).

        textout_ex(bitmapa, font, tekst, x, y, kolor, kolor_tła) - wyświetla tekst
                jako czcionkę (font) można podać czcionkę domyslną (jest w zmiennej globalnej "font")
                jeżeli za kolor_tła podamy -1 tekst wyświetli się z tłem przezroczystym

        floodfill(bitmapa, x, y, kolor) - wypełnia ograniczony obszar danym kolorem,
                przy czym (x,y) wskazuje punkt wnetrza obszaru wypełnianego.

        rectfill(bitmapa, x1, y1, x2, y2, kolor) - rysuje wypełniony prostokat, ktorego
                lewy gorny rog ma wspolrzedne (x1, y1), a prawy dolny (x2-1, y2-1)

        circle(bitmapa, x, y, r, kolor) - kresli okrag o srodku w
                punkcie o wspolrzednych (x, y) i promieniu r

        circlefill(bitmapa, x, y, r, kolor) - jak wyżej, lecz okrąg jest wypełniony

        polygon(bitmapa, ilość_wierzchołków, tablica_współrzędnych, kolor) -
                rysuje wypełniony wielokąt, w tablicy współrzędnych powinny znajdować się
                naprzemian współrzędne X i Y kolejnych wierzchołków wielokąta


*/



// Funkcja główna
int main()
{
        allegro_init();                         // Inicjalizacja biblioteki Allegro
        install_keyboard();                     // Inicjalizacja obsługi klawiatury

        // Uruchomienie trybu graficznego
        // Pracujemy w oknie (WINDOWED) w rozdzielczości 640x480
        // z 32-bitowym kolorem.
        set_color_depth(32);
        set_gfx_mode(GFX_AUTODETECT_WINDOWED, 1280, 1024, 0, 0);

        // Utwórz bitmapę, na której będzie się odbywało rysowanie
        // Bitmapa ma szerokość i wysokość taką, jak nasz "ekran"
        buffer = create_bitmap(SCREEN_W,SCREEN_H);

        //

        // Definicja wieloboku
        const int N = 3;
        int triangleRedX[N]={-100,0,100};
        int triangleRedY[N]={-150,-325,-150};
        int triangleYellowX[N]={-50,0,50};
        int triangleYellowY[N]={-175,-275,-175};

        // Tablice na przetworzone współrzędna punktów
        int pointsRed[2*N];
        int pointsYellow[2*N];

        // Zmienne na potrzeby obracania figury
        double fi=0.0, dfi=0.1, sinfi, cosfi;//kat obrotu
        double zoom=1.0;
        int move = 0;


        // Pętla główna programu, tablica globalna key[] przechowuje
        // aktualny stan (wciśnięty/puszczony) wszystkich klawiszy.
        // Działamy, dopóki użytkownik nie wciśnie Esc.
        while(!key[KEY_ESC])
        {
                // Wyczyść bitmapę
                clear(buffer);

                // Wyznacz środek ekranu;
                int xm = SCREEN_W/2 + move;
                int ym = SCREEN_H/2;
                // Obrót figury
                sinfi = sin(fi);
                cosfi = cos(fi);
                for( int i=0; i<N; i++ )
                {
                        pointsRed[2*i  ] = (int)( zoom*triangleRedX[i]*cosfi - zoom*triangleRedY[i]*sinfi + 0.5) + xm;
                        pointsRed[2*i+1] = (int)( zoom*triangleRedX[i]*sinfi + zoom*triangleRedY[i]*cosfi + 0.5) + ym;
                        pointsYellow[2*i  ] = (int)( zoom*triangleYellowX[i]*cosfi - zoom*triangleYellowY[i]*sinfi + 0.5) + xm;
                        pointsYellow[2*i+1] = (int)( zoom*triangleYellowX[i]*sinfi + zoom*triangleYellowY[i]*cosfi + 0.5) + ym;
                }
                fi += dfi;
                if(key[KEY_UP])
                {
                    if(zoom<10) zoom+=0.01;
                }
                if(key[KEY_DOWN])
                {
                    if (zoom > 0 ) zoom-=0.01;
                }
                if(key[KEY_LEFT])
                {
                    move-=5;
                }
                if(key[KEY_RIGHT])
                {
                    move+=5;
                }
                // Kolory rysowania
                int c0 = makecol( 255, 255,   0 );      // żółty
                int c1 = makecol( 255, 0, 0 );  // czerwony

                // Narysuj wypełniony wielokat
                polygon( buffer, N, pointsRed, c0 );
                polygon( buffer, N, pointsYellow, c1 );

                // Poczekaj aż karta graficzna skończy wyświetlać aktualny obraz.
                // Inaczej moglibyśmy podmienić grafikę w trakcie jej wyświetlania
                // przez kartę, przez co na ekranie przez chwilę byłby widoczny
                // obraz złożony z fragmentów różnych klatek.
                vsync();

                // Skopiuj bufor na ekran
                // (screen jest bitmapą reprezentującą powierzchnię ekranu,
                //  a blit() jest funkcją kopiującą prostokątne obszary bitmap)
                blit(buffer,screen,0,0,0,0,SCREEN_W,SCREEN_H);

                // Odczekaj 10 milisekund
                rest(10);
        }
        //rest(1000);
        // Usuń bitmapę bufora
        destroy_bitmap( buffer );

        // Koniec
        return 0;
}

// Definicja mówiąca Allegro, że powyższa funkcja jest funkcją główną,
// co pozwala skompilować powyższy kod bez żadnych zmian na wielu
// systemach operacyjnych.
END_OF_MAIN()