LAB5 - GKiM

#ifdef __cplusplus
    #include <cstdlib>
#else
    #include <stdlib.h>

#endif
#include <SDL/SDL.h>
#include <math.h>
#define pi 3.1415926536
#include <time.h>
#include <iostream>
using namespace std;

SDL_Surface *screen;
int width = 900;
int height = 600;
char const* tytul = "GKiM2019 - Lab 5 - Banys Karolina";

struct Linia /**wspolrzedne poczatku i konca linii**/
{
    int xp;
    int yp;
    int xk;
    int yk;
};

/**wspolrzedne poszczegolnych odcinkow tworzacych mlotek**/
Linia wzorzec[]={{0,0,0,20}, //AB
                  {0,20,10,20}, //BC
                  {10,20,10,60},//CD
                  {10,60,30,60},//DE
                  {30,60,30,20}, //EF
                  {30,20,40,20}, //FG
                  {40,20,20,0}, //GH
                  {20,0,0,0},}; //HA
Linia mlotek[8]; /**tablica dla mlotka, mlotek to kopia zapasowa wzorca**/

void setPixel(int x, int y, Uint8 R, Uint8 G, Uint8 B);
SDL_Color getPixel (int x, int y);

void czyscEkran(Uint8 R, Uint8 G, Uint8 B);

void Linia(int x1, int y1, int x2, int y2, Uint8 R, Uint8 G, Uint8 B);
void Okrag(int x, int y, int r, Uint8 R, Uint8 G, Uint8 B);
void Elipsa(int x, int y, int a, int b, Uint8 R, Uint8 G, Uint8 B);

void inicjalizacja() /**wpisanie do mlotka wzorca**/
{
    for(int i=0;i<8;i++)
    {
        mlotek[i]=wzorzec[i];
    }
}

void rysowanie(Uint8 R, Uint8 G, Uint8 B) /**rysowanie odcinkow tworzacych mlotek**/
{
     for(int i=0;i<8;i++)
    {
        Linia(mlotek[i].xp, mlotek[i].yp,mlotek[i].xk,mlotek[i].yk,R,G,B );
    }
}

void Funkcja1();
void Funkcja2();
void Funkcja3();
void Funkcja4();
void Funkcja5();
void Funkcja6();
void Funkcja7();
void Funkcja8();
void Funkcja9();



void Funkcja1() /**rysujemy mlotek**/
{
    inicjalizacja();
    rysowanie(255,255,255);

    SDL_Flip(screen);
}

void przesuniecie(int px, int py)
{
    for(int i=0;i<8;i++)
    {
        mlotek[i].xp+=px;
        mlotek[i].yp+=py;
        mlotek[i].xk+=px;
        mlotek[i].yk+=py;
    }
}

void Funkcja2() /**przesuwamy mlotek tak jakby po przekatnej, nie zmieniajac jego wielkosci**/
{
    rysowanie(0,0,0); /**jak zakomentujemy to stare mlotki zostaja na ekranie**/
    przesuniecie(20,10);
    rysowanie(0,255,255);

    SDL_Flip(screen);
}

void skalowanie(float sx, float sy)
{
    for(int i=0;i<8;i++)
    {
        mlotek[i].xp*=sx;
        mlotek[i].yp*=sy;
        mlotek[i].xk*=sx;
        mlotek[i].yk*=sy;
    }
}

void Funkcja3() /**zwiekszamy wielkosc mlotka w odpowiednich proporcjach**/
{
    rysowanie(0,0,0);
    int przesuniecieX = mlotek[0].xp;
    int przesuniecieY = mlotek[0].yp;
    przesuniecie(-przesuniecieX, -przesuniecieY);
    skalowanie(1.1,1.1);
    przesuniecie(przesuniecieX, przesuniecieY);
    rysowanie(rand()%255,255,0);

    SDL_Flip(screen);
}

bool porownajKolory(SDL_Color k1, SDL_Color k2)
{
    bool wynik=true;
    if(k1.r!=k2.r)
        wynik=false;

    if(k1.g!=k2.g)
        wynik=false;

    if(k1.b!=k2.b)
        wynik=false;

    return wynik;
}

void sianie(int x, int y, SDL_Color kolorWypelnienia, SDL_Color
kolorBrzegu)
{
    setPixel(x,y,kolorWypelnienia.r, kolorWypelnienia.g,
kolorWypelnienia.b);

    SDL_Color kolor;
    kolor=getPixel(x-1, y);
    if((!porownajKolory(kolor,kolorWypelnienia)) &&
        (!porownajKolory(kolor,kolorBrzegu)))
    {
        sianie(x-1, y, kolorWypelnienia,kolorBrzegu);
    }

    kolor=getPixel(x, y-1);
    if((!porownajKolory(kolor,kolorWypelnienia)) &&
        (!porownajKolory(kolor,kolorBrzegu)))
    {
        sianie(x, y-1, kolorWypelnienia,kolorBrzegu);
    }

    kolor=getPixel(x+1, y);
    if((!porownajKolory(kolor,kolorWypelnienia)) &&
        (!porownajKolory(kolor,kolorBrzegu)))
    {
        sianie(x+1, y, kolorWypelnienia,kolorBrzegu);
    }

    kolor=getPixel(x, y+1);
    if((!porownajKolory(kolor,kolorWypelnienia)) &&
        (!porownajKolory(kolor,kolorBrzegu)))
    {
        sianie(x, y+1, kolorWypelnienia,kolorBrzegu);
    }
}

void Funkcja4() /**rysujemy okrag o okreslonym kolorze brzegu i o okreslonym kolorze wypelnienia**/
{

    SDL_Color brzeg={255,255,255}; /**kolor brzegu okregu**/
    SDL_Color wypelnienie={.r=255, .g=0, .b=255}; /**kolor wypelnienia okregu**/

    Okrag(300,300,50,brzeg.r,brzeg.g,brzeg.b); /**rysuje okrag o brzegu bialym**/

    sianie(300,300,wypelnienie,brzeg); /**wypelnia wnetrze okregu kolorem magenta**/


    SDL_Flip(screen);
}

/**jezeli wywolamy funkcje 5 i 4 to powstaly okrag "zasloni" linie**/

void Funkcja5() /**rysuje linie o randomowych wspolrzednych poczatku i konca tej linii i o randomowych kolorach**/
{

  Linia(rand()%width, rand()%height,
          rand()%width, rand()%height,
          rand()%255, rand()%255, rand()%255);

    /**Linia(rand()%width, rand()%height,
          rand()%width, rand()%height,
          255, 0, 255);**/

    SDL_Flip(screen);
}

void sianie2(int x, int y, SDL_Color kolorWypelnienia, SDL_Color kolorTla)
{
    setPixel(x,y,kolorWypelnienia.r, kolorWypelnienia.g, kolorWypelnienia.b);
    //SDL_Flip(screen);

    SDL_Color kolor;

    kolor=getPixel(x-1, y);

    if(porownajKolory(kolor, kolorTla))
    {
        sianie2(x-1, y, kolorWypelnienia,kolorTla);
    }

    kolor=getPixel(x, y-1);

    if(porownajKolory(kolor, kolorTla))
    {
        sianie2(x, y-1, kolorWypelnienia,kolorTla);
    }

    kolor=getPixel(x+1, y);

    if(porownajKolory(kolor, kolorTla))
    {
        sianie2(x+1, y, kolorWypelnienia,kolorTla);
    }

    kolor=getPixel(x, y+1);

    if(porownajKolory(kolor, kolorTla))
    {
        sianie2(x, y+1, kolorWypelnienia,kolorTla);
    }
}

/**jezeli wywolamy funkcje 6 i 5 to powstaly okrag "nie zasloni" linii**/

void Funkcja6()
{

    SDL_Color tlo=getPixel(300,300);
    SDL_Color wypelnienie={.r=255, .g=255, .b=0};

    Okrag(300,300,50,255,0,255);

    sianie2(300,300,wypelnienie,tlo);
    SDL_Flip(screen);
}


void Funkcja7()
{

  inicjalizacja();
  rysowanie(0,255,255);
  SDL_Color brzeg = {0,255,255};
  SDL_Color wypelnienie = {255,255,0};

  sianie(mlotek[0].xp+20, mlotek[0].yp+20, wypelnienie, brzeg);

    SDL_Flip(screen);
}


void Funkcja8() {

    //...

    SDL_Flip(screen);
}


void Funkcja9() {

    //...

    SDL_Flip(screen);
}


void Linia(int x1, int y1, int x2, int y2, Uint8 R, Uint8 G, Uint8 B) {
    setPixel(x1,y1,R,G,B);
    setPixel(x2,y2,R,G,B);
     // zmienne pomocnicze
     int d, dx, dy, ai, bi, xi, yi;
     int x = x1, y = y1;
     // ustalenie kierunku rysowania
     if (x1 < x2)
     {
         xi = 1;
         dx = x2 - x1;
     }
     else
     {
         xi = -1;
         dx = x1 - x2;
     }
     // ustalenie kierunku rysowania
     if (y1 < y2)
     {
         yi = 1;
         dy = y2 - y1;
     }
     else
     {
         yi = -1;
         dy = y1 - y2;
     }
     // pierwszy piksel
     setPixel(x, y, R, G, B);
     // oś wiodąca OX
     if (dx > dy)
     {
         ai = (dy - dx) * 2;
         bi = dy * 2;
         d = bi - dx;
         // pętla po kolejnych x
         while (x != x2)
         {
             // test współczynnika
             if (d >= 0)
             {
                 x += xi;
                 y += yi;
                 d += ai;
             }
             else
             {
                 d += bi;
                 x += xi;
             }
             setPixel(x, y, R, G, B);
         }
     }
     // oś wiodąca OY
     else
     {
         ai = ( dx - dy ) * 2;
         bi = dx * 2;
         d = bi - dy;
         // pętla po kolejnych y
         while (y != y2)
         {
             // test współczynnika
             if (d >= 0)
             {
                 x += xi;
                 y += yi;
                 d += ai;
             }
             else
             {
                 d += bi;
                 y += yi;
             }
             setPixel(x, y, R, G, B);
         }
     }
    SDL_Flip(screen);
}

void RysujOkrag(int x0, int y0, int x, int y, Uint8 R, Uint8 G, Uint8 B){
    setPixel(x+x0, y+y0, R, G, B);
    setPixel(y+x0, x+y0, R, G, B);
    setPixel(y+x0, -x+y0, R, G, B);
    setPixel(x+x0, -y+y0, R, G, B);
    setPixel(-x+x0, -y+y0, R, G, B);
    setPixel(-y+x0, -x+y0, R, G, B);
    setPixel(-y+x0, x+y0, R, G, B);
    setPixel(-x+x0, y+y0, R, G, B);;
}


void Okrag(int x0, int y0, int r, Uint8 R, Uint8 G, Uint8 B) {
    int x =0;
    int y=r;
    int d = 3-2*r;

    while (x <= y){
        if (d<0){
            d=d+4*x+6;
            RysujOkrag(x0, y0, x, y, R, G, B);
        } else{
            d=d+4*(x-y)+10;
            y--;
            RysujOkrag(x0, y0, x, y, R, G, B);
        }
        x++;
    }
    SDL_Flip(screen);
}

void Elipsa(int x, int y, int a, int b, Uint8 R, Uint8 G, Uint8 B) {
    int xc  = 0,
        yc  = b;
    int aa  = a * a,
        aa2 = aa + aa,
        bb  = b * b,
        bb2 = bb + bb;
    int d   = bb - aa * b + (aa / 4),
        dx  = 0,
        dy  = aa2 * b;

    while (dx < dy) {
        setPixel (x - xc,y - yc, R, G, B);
        setPixel (x - xc,y + yc, R, G, B);
        setPixel (x + xc,y - yc, R, G, B);
        setPixel (x + xc,y + yc, R, G, B);
        if (d > 0){
            yc  = yc-1;
            dy -= aa2;
            d  -= dy;
        }
        xc  =xc+1;
        dx += bb2;
        d  += bb + dx;
    }
    d += (3 * ((aa - bb) / 2) - (dx + dy) / 2);

    while (yc >= 0) {
        setPixel (x - xc,y - yc, R, G, B);
        setPixel (x - xc,y + yc, R, G, B);
        setPixel (x + xc,y - yc, R, G, B);
        setPixel (x + xc,y + yc, R, G, B);
        if (d < 0) {
            xc =xc+1;
            dx += bb2;
            d  += (bb + dx);
        }
        yc  = yc-1;
        dy -= aa2;
        d  += aa - dy;
    }
    SDL_Flip(screen);
}



void setPixel(int x, int y, Uint8 R, Uint8 G, Uint8 B)
{
  if ((x>=0) && (x<width) && (y>=0) && (y<height))
  {
    /* Zamieniamy poszczególne składowe koloru na format koloru piksela */
    Uint32 pixel = SDL_MapRGB(screen->format, R, G, B);

    /* Pobieramy informację ile bajtów zajmuje jeden piksel */
    int bpp = screen->format->BytesPerPixel;

    /* Obliczamy adres piksela */
    Uint8 *p = (Uint8 *)screen->pixels + y * screen->pitch + x * bpp;

    /* Ustawiamy wartość piksela, w zależności od formatu powierzchni*/
    switch(bpp)
    {
        case 1: //8-bit
            *p = pixel;
            break;

        case 2: //16-bit
            *(Uint16 *)p = pixel;
            break;

        case 3: //24-bit
            if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
                p[0] = (pixel >> 16) & 0xff;
                p[1] = (pixel >> 8) & 0xff;
                p[2] = pixel & 0xff;
            } else {
                p[0] = pixel & 0xff;
                p[1] = (pixel >> 8) & 0xff;
                p[2] = (pixel >> 16) & 0xff;
            }
            break;

        case 4: //32-bit
            *(Uint32 *)p = pixel;
            break;

    }
         /* ewentualna aktualizacja obrazu (aka double buffering) */
  }
}


SDL_Color getPixel (int x, int y) {
    SDL_Color color ;
    Uint32 col = 0 ;
    if ((x>=0) && (x<width) && (y>=0) && (y<height)) {
        //określamy pozycję
        char* pPosition=(char*)screen->pixels ;
        //przesunięcie względem y
        pPosition+=(screen->pitch*y) ;
        //przesunięcie względem x
        pPosition+=(screen->format->BytesPerPixel*x);
        //kopiujemy dane piksela
        memcpy(&col, pPosition, screen->format->BytesPerPixel);
        //konwertujemy kolor
        SDL_GetRGB(col, screen->format, &color.r, &color.g, &color.b);
    }
    return ( color ) ;
}

void czyscEkran(Uint8 R, Uint8 G, Uint8 B)
{
    SDL_FillRect(screen, 0, SDL_MapRGB(screen->format, R, G, B));
    SDL_Flip(screen);

}



int main ( int argc, char** argv )
{
    // console output
    freopen( "CON", "wt", stdout );
    freopen( "CON", "wt", stderr );

    // initialize SDL video
    if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )
    {
        printf( "Unable to init SDL: %s\n", SDL_GetError() );
        return 1;
    }

    // make sure SDL cleans up before exit
    atexit(SDL_Quit);

    // create a new window
    screen = SDL_SetVideoMode(width, height, 32,
                                           SDL_HWSURFACE|SDL_DOUBLEBUF);
    if ( !screen )
    {
        printf("Unable to set video: %s\n", SDL_GetError());
        return 1;
    }

    SDL_WM_SetCaption( tytul , NULL );
    // program main loop
    bool done = false;
    while (!done)
    {
        // message processing loop
        SDL_Event event;
        while (SDL_PollEvent(&event))
        {
            // check for messages
            switch (event.type)
            {
                // exit if the window is closed
            case SDL_QUIT:
                done = true;
                break;

                // check for keypresses
            case SDL_KEYDOWN:
                {
                    // exit if ESCAPE is pressed
                    if (event.key.keysym.sym == SDLK_ESCAPE)
                        done = true;
                    if (event.key.keysym.sym == SDLK_1)
                        Funkcja1();
                    if (event.key.keysym.sym == SDLK_2)
                        Funkcja2();
                    if (event.key.keysym.sym == SDLK_3)
                        Funkcja3();
                    if (event.key.keysym.sym == SDLK_4)
                        Funkcja4();
                    if (event.key.keysym.sym == SDLK_5)
                        Funkcja5();
                    if (event.key.keysym.sym == SDLK_6)
                        Funkcja6();
                    if (event.key.keysym.sym == SDLK_7)
                        Funkcja7();
                    if (event.key.keysym.sym == SDLK_b)
                        czyscEkran(0, 0, 10);          break;
                     }
            } // end switch
        } // end of message processing

    } // end main loop


    // all is well ;)
    printf("Exited cleanly\n");
    return 0;
}