API tools faq
paste
Advertisement
GieeF

Dithering

GieeF
Jan 22nd, 2020
140
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 26.62 KB | None | 0 0
raw download clone embed print report
  1. #ifdef __cplusplus
  2.     #include <cstdlib>
  3. #else
  4.     #include <stdlib.h>
  5.  
  6. #endif
  7. #include <SDL/SDL.h>
  8. #include <math.h>
  9. #define pi 3.1415926536
  10. #include <time.h>
  11. #include <iostream>
  12. using namespace std;
  13.  
  14. SDL_Surface *screen;
  15. int width = 512;
  16. int height = 340;
  17. char const* tytul = "GKiM2019 - Lab 7 - Nazwisko Imie";
  18.  
  19.  
  20. void setPixel(int x, int y, Uint8 R, Uint8 G, Uint8 B);
  21. SDL_Color getPixel (int x, int y);
  22.  
  23. void czyscEkran(Uint8 R, Uint8 G, Uint8 B);
  24.  
  25. void Linia(int x1, int y1, int x2, int y2, Uint8 R, Uint8 G, Uint8 B);
  26. void Okrag(int x, int y, int r, Uint8 R, Uint8 G, Uint8 B);
  27. void Elipsa(int x, int y, int a, int b, Uint8 R, Uint8 G, Uint8 B);
  28. void Funkcja1();
  29. void Funkcja2();
  30. void Funkcja3();
  31. void Funkcja4();
  32. void Funkcja5();
  33. void Funkcja6();
  34. void Funkcja7();
  35. void Funkcja8();
  36. void Funkcja9();
  37.  
  38.  
  39.  
  40. void Funkcja1() //Dithering
  41. {
  42.     SDL_Color kolor;
  43.     SDL_Color nowykolor;
  44.  
  45.     float bledyR[(width/2+2)][height/2+1];
  46.     float bledyG[(width/2+2)][height/2+1];
  47.     float bledyB[(width/2+2)][height/2+1];
  48.  
  49.     memset(bledyR, 0, sizeof(bledyR));
  50.     memset(bledyG, 0, sizeof(bledyG));
  51.     memset(bledyB, 0, sizeof(bledyB));
  52.  
  53.     int bladR, bladG, bladB, R, G, B;
  54.     int przesuniecie=1; //aby nie wyjsc ponizej (-1) tabeli bledow
  55.  
  56.  
  57.  
  58.     for(int y=0; y<height/2; y++)
  59.     {
  60.         for(int x=0; x<width/2; x++)
  61.         {
  62.             kolor =getPixel(x,y);
  63.  
  64.             R=kolor.r+bledyR[x+przesuniecie][y];
  65.             G=kolor.g+bledyG[x+przesuniecie][y];
  66.             B=kolor.b+bledyB[x+przesuniecie][y];
  67.  
  68.             if(R>127){
  69.                 nowykolor.r=255;
  70.                 bladR=R-255;
  71.             }
  72.             else
  73.             {
  74.                 nowykolor.r=0;
  75.                 bladR=R;
  76.             }
  77.  
  78.             if(G>127){
  79.                 nowykolor.g=255;
  80.                 bladG=G-255;
  81.             }
  82.             else
  83.             {
  84.                 nowykolor.g=0;
  85.                 bladG=G;
  86.             }
  87.  
  88.             if(B>127){
  89.                 nowykolor.b=255;
  90.                 bladB=B-255;
  91.             }
  92.             else
  93.             {
  94.                 nowykolor.b=0;
  95.                 bladB=B;
  96.             }
  97.  
  98.             bledyR[x+przesuniecie+1][y  ]+=(bladR*7.0/16.0);
  99.             bledyR[x+przesuniecie+1][y+1]+=(bladR*1.0/16.0);
  100.             bledyR[x+przesuniecie  ][y+1]+=(bladR*5.0/16.0);
  101.             bledyR[x+przesuniecie-1][y+1]+=(bladR*3.0/16.0);
  102.  
  103.             bledyG[x+przesuniecie+1][y  ]+=(bladG*7.0/16.0);
  104.             bledyG[x+przesuniecie+1][y+1]+=(bladG*1.0/16.0);
  105.             bledyG[x+przesuniecie  ][y+1]+=(bladG*5.0/16.0);
  106.             bledyG[x+przesuniecie-1][y+1]+=(bladG*3.0/16.0);
  107.  
  108.             bledyB[x+przesuniecie+1][y  ]+=(bladB*7.0/16.0);
  109.             bledyB[x+przesuniecie+1][y+1]+=(bladB*1.0/16.0);
  110.             bledyB[x+przesuniecie  ][y+1]+=(bladB*5.0/16.0);
  111.             bledyB[x+przesuniecie-1][y+1]+=(bladB*3.0/16.0);
  112.  
  113.  
  114.             setPixel(x+width/2,y,nowykolor.r, nowykolor.g, nowykolor.b);
  115.             setPixel(x+width/2,y+height/2,R, G, B);
  116.         }
  117.     }
  118.     SDL_Flip(screen);
  119. }
  120.  
  121.  
  122. void Funkcja2() {
  123.  
  124.     SDL_Color kolor;
  125.  
  126.     float bledy[width/2+2][height/2+1];
  127.     memset(bledy, 0, sizeof(bledy));
  128.  
  129.     int BWrysowane, BW=0, przesuniecie=1, blad=0;
  130.  
  131.     for(int y=0; y<height/2; y++)
  132.     {
  133.         for(int x=0; x<width/2; x++)
  134.         {
  135.             kolor=getPixel(x,y);
  136.             BW=0.299*kolor.r+0.587*kolor.g+0.114*kolor.b;
  137.  
  138.             BW+=bledy[x+przesuniecie][y];
  139.  
  140.             BWrysowane=BW;          //aby nie wychodzic poza zakres
  141.             if(BWrysowane>255)
  142.                 BWrysowane=255;
  143.  
  144.             if(BWrysowane<0)
  145.                 BWrysowane=0;
  146.  
  147.             setPixel(x+width/2, y+height/2, BWrysowane,BWrysowane, BWrysowane);
  148.  
  149.             if(BW<64)
  150.             {
  151.                 setPixel(x+(width/2), y, 0,0,0);
  152.                 blad=BW;
  153.             }
  154.  
  155.             else if((BW>=64)&&(BW<128))
  156.             {
  157.                 setPixel(x+(width/2), y, 85, 85, 85);
  158.                 blad=BW-85;
  159.             }
  160.  
  161.             else if((BW>=128)&&(BW<192))
  162.             {
  163.                 setPixel(x+(width/2), y, 170, 170, 170);
  164.                 blad=BW-170;
  165.             }
  166.  
  167.             else
  168.             {
  169.                 setPixel(x+(width/2), y, 255,255,255);
  170.                 blad=BW-255;
  171.             }
  172.  
  173.             bledy[x+przesuniecie+1][y  ]+=(blad*7.0/16.0);
  174.             bledy[x+przesuniecie+1][y+1]+=(blad*1.0/16.0);
  175.             bledy[x+przesuniecie  ][y+1]+=(blad*5.0/16.0);
  176.             bledy[x+przesuniecie-1][y+1]+=(blad*3.0/16.0);
  177.         }
  178.     }
  179.  
  180.     SDL_Flip(screen);
  181. }
  182.  
  183. void Funkcja3() {
  184.  
  185.     SDL_Color kolor;
  186.     SDL_Color nowykolor;
  187.  
  188.     float bledyR[(width/2+2)][height/2+1];
  189.     float bledyG[(width/2+2)][height/2+1];
  190.     float bledyB[(width/2+2)][height/2+1];
  191.  
  192.     memset(bledyR, 0, sizeof(bledyR));
  193.     memset(bledyG, 0, sizeof(bledyG));
  194.     memset(bledyB, 0, sizeof(bledyB));
  195.  
  196.     int bladR, bladG, bladB, R, G, B;
  197.     int przesuniecie=1; //aby nie wyjsc ponizej (-1) tabeli bledow
  198.  
  199.     int red, green, blue, black, white;
  200.  
  201.     for(int y=0; y<height/2; y++)
  202.     {
  203.         for(int x=0; x<width/2; x++)
  204.         {
  205.             kolor = getPixel(x,y);
  206.  
  207.             R=kolor.r+bledyR[x+przesuniecie][y];
  208.             G=kolor.g+bledyG[x+przesuniecie][y];
  209.             B=kolor.b+bledyB[x+przesuniecie][y];
  210.             /*
  211.             red = 255 - R + G + B;
  212.             green = R + 255 - G + B;
  213.             blue = R + G + 255 - B;
  214.             */
  215.             red = 255 - R;
  216.             green = 255 - G;
  217.             blue = 255 - B;
  218.             black = R + G + B;
  219.             white = 255 - R + 255 - G + 255 - B;
  220.  
  221.             if(min(red,min(green,min(blue,min(black,white)))) == red) {
  222.                 nowykolor.r = 255;
  223.                 bladR = R-255;
  224.                 nowykolor.g = 0;
  225.                 bladG = G;
  226.                 nowykolor.b = 0;
  227.                 bladB = B;
  228.             }
  229.             if(min(red,min(green,min(blue,min(black,white)))) == green) {
  230.                 nowykolor.r = 0;
  231.                 bladR = R;
  232.                 nowykolor.g = 255;
  233.                 bladG = G-255;
  234.                 nowykolor.b = 0;
  235.                 bladB = B;
  236.             }
  237.             if(min(red,min(green,min(blue,min(black,white)))) == blue) {
  238.                 nowykolor.r = 0;
  239.                 bladR = R;
  240.                 nowykolor.g = 0;
  241.                 bladG = G;
  242.                 nowykolor.b = 255;
  243.                 bladB = B-255;
  244.             }
  245.             if(min(red,min(green,min(blue,min(black,white)))) == black) {
  246.                 nowykolor.r = 0;
  247.                 bladR = R;
  248.                 nowykolor.g = 0;
  249.                 bladG = G;
  250.                 nowykolor.b = 0;
  251.                 bladB = B;
  252.             }
  253.             if(min(red,min(green,min(blue,min(black,white)))) == white) {
  254.                 nowykolor.r = 255;
  255.                 bladR = R-255;
  256.                 nowykolor.g = 255;
  257.                 bladG = G-255;
  258.                 nowykolor.b = 255;
  259.                 bladB = B-255;
  260.             }
  261.  
  262.             bledyR[x+przesuniecie+1][y  ]+=(bladR*7.0/16.0);
  263.             bledyR[x+przesuniecie+1][y+1]+=(bladR*1.0/16.0);
  264.             bledyR[x+przesuniecie  ][y+1]+=(bladR*5.0/16.0);
  265.             bledyR[x+przesuniecie-1][y+1]+=(bladR*3.0/16.0);
  266.  
  267.             bledyG[x+przesuniecie+1][y  ]+=(bladG*7.0/16.0);
  268.             bledyG[x+przesuniecie+1][y+1]+=(bladG*1.0/16.0);
  269.             bledyG[x+przesuniecie  ][y+1]+=(bladG*5.0/16.0);
  270.             bledyG[x+przesuniecie-1][y+1]+=(bladG*3.0/16.0);
  271.  
  272.             bledyB[x+przesuniecie+1][y  ]+=(bladB*7.0/16.0);
  273.             bledyB[x+przesuniecie+1][y+1]+=(bladB*1.0/16.0);
  274.             bledyB[x+przesuniecie  ][y+1]+=(bladB*5.0/16.0);
  275.             bledyB[x+przesuniecie-1][y+1]+=(bladB*3.0/16.0);
  276.  
  277.  
  278.             setPixel(x+width/2,y,nowykolor.r, nowykolor.g, nowykolor.b);
  279.             setPixel(x+width/2,y+height/2,R, G, B);
  280.         }
  281.     }
  282.  
  283.     SDL_Flip(screen);
  284. }
  285.  
  286. void Funkcja4() {
  287.  
  288.     SDL_Color kolor;
  289.     SDL_Color nowykolor;
  290.  
  291.     float bledyR[(width/2+2)][height/2+1];
  292.     float bledyG[(width/2+2)][height/2+1];
  293.     float bledyB[(width/2+2)][height/2+1];
  294.  
  295.     memset(bledyR, 0, sizeof(bledyR));
  296.     memset(bledyG, 0, sizeof(bledyG));
  297.     memset(bledyB, 0, sizeof(bledyB));
  298.  
  299.     int bladR, bladG, bladB, R, G, B;
  300.     int przesuniecie=1; //aby nie wyjsc ponizej (-1) tabeli bledow
  301.  
  302.     int cyan, magenta, yellow, black, white;
  303.  
  304.     for(int y=0; y<height/2; y++)
  305.     {
  306.         for(int x=0; x<width/2; x++)
  307.         {
  308.             kolor = getPixel(x,y);
  309.  
  310.             R=kolor.r+bledyR[x+przesuniecie][y];
  311.             G=kolor.g+bledyG[x+przesuniecie][y];
  312.             B=kolor.b+bledyB[x+przesuniecie][y];
  313.  
  314.             cyan = R + 255 - G + 255 - B;
  315.             magenta = 255 - R + G + 255 - B;
  316.             yellow = 255 - R + 255 - G + B;
  317.             black = R + G + B;
  318.             white = 255 - R + 255 - G + 255 - B;
  319.  
  320.             if(min(cyan,min(magenta,min(yellow,min(black,white)))) == cyan) {
  321.                 nowykolor.r = 0;
  322.                 bladR = R;
  323.                 nowykolor.g = 255;
  324.                 bladG = G-255;
  325.                 nowykolor.b = 255;
  326.                 bladB = B-255;
  327.             }
  328.             if(min(cyan,min(magenta,min(yellow,min(black,white)))) == magenta) {
  329.                 nowykolor.r = 255;
  330.                 bladR = R-255;
  331.                 nowykolor.g = 0;
  332.                 bladG = G;
  333.                 nowykolor.b = 255;
  334.                 bladB = B-255;
  335.             }
  336.             if(min(cyan,min(magenta,min(yellow,min(black,white)))) == yellow) {
  337.                 nowykolor.r = 255;
  338.                 bladR = R-255;
  339.                 nowykolor.g = 255;
  340.                 bladG = G-255;
  341.                 nowykolor.b = 0;
  342.                 bladB = B;
  343.             }
  344.             if(min(cyan,min(magenta,min(yellow,min(black,white)))) == black) {
  345.                 nowykolor.r = 0;
  346.                 bladR = R;
  347.                 nowykolor.g = 0;
  348.                 bladG = G;
  349.                 nowykolor.b = 0;
  350.                 bladB = B;
  351.             }
  352.             if(min(cyan,min(magenta,min(yellow,min(black,white)))) == white) {
  353.                 nowykolor.r = 255;
  354.                 bladR = R-255;
  355.                 nowykolor.g = 255;
  356.                 bladG = G-255;
  357.                 nowykolor.b = 255;
  358.                 bladB = B-255;
  359.             }
  360.  
  361.             bledyR[x+przesuniecie+1][y  ]+=(bladR*7.0/16.0);
  362.             bledyR[x+przesuniecie+1][y+1]+=(bladR*1.0/16.0);
  363.             bledyR[x+przesuniecie  ][y+1]+=(bladR*5.0/16.0);
  364.             bledyR[x+przesuniecie-1][y+1]+=(bladR*3.0/16.0);
  365.  
  366.             bledyG[x+przesuniecie+1][y  ]+=(bladG*7.0/16.0);
  367.             bledyG[x+przesuniecie+1][y+1]+=(bladG*1.0/16.0);
  368.             bledyG[x+przesuniecie  ][y+1]+=(bladG*5.0/16.0);
  369.             bledyG[x+przesuniecie-1][y+1]+=(bladG*3.0/16.0);
  370.  
  371.             bledyB[x+przesuniecie+1][y  ]+=(bladB*7.0/16.0);
  372.             bledyB[x+przesuniecie+1][y+1]+=(bladB*1.0/16.0);
  373.             bledyB[x+przesuniecie  ][y+1]+=(bladB*5.0/16.0);
  374.             bledyB[x+przesuniecie-1][y+1]+=(bladB*3.0/16.0);
  375.  
  376.  
  377.             setPixel(x+width/2,y,nowykolor.r, nowykolor.g, nowykolor.b);
  378.             setPixel(x+width/2,y+height/2,R, G, B);
  379.         }
  380.     }
  381.  
  382.     SDL_Flip(screen);
  383. }
  384.  
  385.  
  386. void Funkcja5() {
  387.  
  388.     SDL_Color kolor;
  389.     SDL_Color nowykolor;
  390.  
  391.     float bledyR[(width/2+2)][height/2+1];
  392.     float bledyG[(width/2+2)][height/2+1];
  393.     float bledyB[(width/2+2)][height/2+1];
  394.  
  395.     memset(bledyR, 0, sizeof(bledyR));
  396.     memset(bledyG, 0, sizeof(bledyG));
  397.     memset(bledyB, 0, sizeof(bledyB));
  398.  
  399.     int bladR, bladG, bladB, R, G, B;
  400.     int przesuniecie=1; //aby nie wyjsc ponizej (-1) tabeli bledow
  401.  
  402.     int red, green, blue, black, white;
  403.  
  404.     for(int y=0; y<height/2; y++)
  405.     {
  406.         for(int x=0; x<width/2; x++)
  407.         {
  408.             kolor = getPixel(x,y);
  409.  
  410.             R=kolor.r+bledyR[x+przesuniecie][y];
  411.             G=kolor.g+bledyG[x+przesuniecie][y];
  412.             B=kolor.b+bledyB[x+przesuniecie][y];
  413.  
  414.             red = 255 - R + G + B;
  415.             green = R + 255 - G + B;
  416.             blue = R + G + 255 - B;
  417.             black = R + G + B;
  418.             white = 255 - R + 255 - G + 255 - B;
  419.  
  420.             if(min(red,min(green,min(blue,min(black,white)))) == red) {
  421.                 nowykolor.r = 255;
  422.                 bladR = R-255;
  423.                 nowykolor.g = 0;
  424.                 bladG = G;
  425.                 nowykolor.b = 0;
  426.                 bladB = B;
  427.             }
  428.             if(min(red,min(green,min(blue,min(black,white)))) == green) {
  429.                 nowykolor.r = 0;
  430.                 bladR = R;
  431.                 nowykolor.g = 255;
  432.                 bladG = G-255;
  433.                 nowykolor.b = 0;
  434.                 bladB = B;
  435.             }
  436.             if(min(red,min(green,min(blue,min(black,white)))) == blue) {
  437.                 nowykolor.r = 0;
  438.                 bladR = R;
  439.                 nowykolor.g = 0;
  440.                 bladG = G;
  441.                 nowykolor.b = 255;
  442.                 bladB = B-255;
  443.             }
  444.             if(min(red,min(green,min(blue,min(black,white)))) == black) {
  445.                 nowykolor.r = 0;
  446.                 bladR = R;
  447.                 nowykolor.g = 0;
  448.                 bladG = G;
  449.                 nowykolor.b = 0;
  450.                 bladB = B;
  451.             }
  452.             if(min(red,min(green,min(blue,min(black,white)))) == white) {
  453.                 nowykolor.r = 255;
  454.                 bladR = R-255;
  455.                 nowykolor.g = 255;
  456.                 bladG = G-255;
  457.                 nowykolor.b = 255;
  458.                 bladB = B-255;
  459.             }
  460.  
  461.             bledyR[x+przesuniecie+1][y  ]+=(bladR*7.0/16.0);
  462.             bledyR[x+przesuniecie+1][y+1]+=(bladR*1.0/16.0);
  463.             bledyR[x+przesuniecie  ][y+1]+=(bladR*5.0/16.0);
  464.             bledyR[x+przesuniecie-1][y+1]+=(bladR*3.0/16.0);
  465.  
  466.             bledyG[x+przesuniecie+1][y  ]+=(bladG*7.0/16.0);
  467.             bledyG[x+przesuniecie+1][y+1]+=(bladG*1.0/16.0);
  468.             bledyG[x+przesuniecie  ][y+1]+=(bladG*5.0/16.0);
  469.             bledyG[x+przesuniecie-1][y+1]+=(bladG*3.0/16.0);
  470.  
  471.             bledyB[x+przesuniecie+1][y  ]+=(bladB*7.0/16.0);
  472.             bledyB[x+przesuniecie+1][y+1]+=(bladB*1.0/16.0);
  473.             bledyB[x+przesuniecie  ][y+1]+=(bladB*5.0/16.0);
  474.             bledyB[x+przesuniecie-1][y+1]+=(bladB*3.0/16.0);
  475.  
  476.  
  477.             setPixel(x+width/2,y,nowykolor.r, nowykolor.g, nowykolor.b);
  478.             setPixel(x+width/2,y+height/2,R, G, B);
  479.         }
  480.     }
  481.  
  482.     SDL_Flip(screen);
  483. }
  484.  
  485.  
  486. void Funkcja6() {
  487.  
  488.     //...
  489.  
  490.     SDL_Flip(screen);
  491. }
  492.  
  493.  
  494. void Funkcja7() {
  495.  
  496.     //...
  497.  
  498.     SDL_Flip(screen);
  499. }
  500.  
  501.  
  502. void Funkcja8() {
  503.  
  504.     //...
  505.  
  506.     SDL_Flip(screen);
  507. }
  508.  
  509.  
  510. void Funkcja9() {
  511.  
  512.     //...
  513.  
  514.     SDL_Flip(screen);
  515. }
  516.  
  517.  
  518. void Linia(int x1, int y1, int x2, int y2, Uint8 R, Uint8 G, Uint8 B) {
  519.     setPixel(x1,y1,R,G,B);
  520.     setPixel(x2,y2,R,G,B);
  521.      // zmienne pomocnicze
  522.      int d, dx, dy, ai, bi, xi, yi;
  523.      int x = x1, y = y1;
  524.      // ustalenie kierunku rysowania
  525.      if (x1 < x2)
  526.      {
  527.          xi = 1;
  528.          dx = x2 - x1;
  529.      }
  530.      else
  531.      {
  532.          xi = -1;
  533.          dx = x1 - x2;
  534.      }
  535.      // ustalenie kierunku rysowania
  536.      if (y1 < y2)
  537.      {
  538.          yi = 1;
  539.          dy = y2 - y1;
  540.      }
  541.      else
  542.      {
  543.          yi = -1;
  544.          dy = y1 - y2;
  545.      }
  546.      // pierwszy piksel
  547.      setPixel(x, y, R, G, B);
  548.      // oś wiodąca OX
  549.      if (dx > dy)
  550.      {
  551.          ai = (dy - dx) * 2;
  552.          bi = dy * 2;
  553.          d = bi - dx;
  554.          // pętla po kolejnych x
  555.          while (x != x2)
  556.          {
  557.              // test współczynnika
  558.              if (d >= 0)
  559.              {
  560.                  x += xi;
  561.                  y += yi;
  562.                  d += ai;
  563.              }
  564.              else
  565.              {
  566.                  d += bi;
  567.                  x += xi;
  568.              }
  569.              setPixel(x, y, R, G, B);
  570.          }
  571.      }
  572.      // oś wiodąca OY
  573.      else
  574.      {
  575.          ai = ( dx - dy ) * 2;
  576.          bi = dx * 2;
  577.          d = bi - dy;
  578.          // pętla po kolejnych y
  579.          while (y != y2)
  580.          {
  581.              // test współczynnika
  582.              if (d >= 0)
  583.              {
  584.                  x += xi;
  585.                  y += yi;
  586.                  d += ai;
  587.              }
  588.              else
  589.              {
  590.                  d += bi;
  591.                  y += yi;
  592.              }
  593.              setPixel(x, y, R, G, B);
  594.          }
  595.      }
  596.     SDL_Flip(screen);
  597. }
  598.  
  599. void RysujOkrag(int x0, int y0, int x, int y, Uint8 R, Uint8 G, Uint8 B){
  600.     setPixel(x+x0, y+y0, R, G, B);
  601.     setPixel(y+x0, x+y0, R, G, B);
  602.     setPixel(y+x0, -x+y0, R, G, B);
  603.     setPixel(x+x0, -y+y0, R, G, B);
  604.     setPixel(-x+x0, -y+y0, R, G, B);
  605.     setPixel(-y+x0, -x+y0, R, G, B);
  606.     setPixel(-y+x0, x+y0, R, G, B);
  607.     setPixel(-x+x0, y+y0, R, G, B);;
  608. }
  609.  
  610.  
  611. void Okrag(int x0, int y0, int r, Uint8 R, Uint8 G, Uint8 B) {
  612.     int x =0;
  613.     int y=r;
  614.     int d = 3-2*r;
  615.  
  616.     while (x <= y){
  617.         if (d<0){
  618.             d=d+4*x+6;
  619.             RysujOkrag(x0, y0, x, y, R, G, B);
  620.         } else{
  621.             d=d+4*(x-y)+10;
  622.             y--;
  623.             RysujOkrag(x0, y0, x, y, R, G, B);
  624.         }
  625.         x++;
  626.     }
  627.     SDL_Flip(screen);
  628. }
  629.  
  630. void Elipsa(int x, int y, int a, int b, Uint8 R, Uint8 G, Uint8 B) {
  631.     int xc  = 0,
  632.         yc  = b;
  633.     int aa  = a * a,
  634.         aa2 = aa + aa,
  635.         bb  = b * b,
  636.         bb2 = bb + bb;
  637.     int d   = bb - aa * b + (aa / 4),
  638.         dx  = 0,
  639.         dy  = aa2 * b;
  640.  
  641.     while (dx < dy) {
  642.         setPixel (x - xc,y - yc, R, G, B);
  643.         setPixel (x - xc,y + yc, R, G, B);
  644.         setPixel (x + xc,y - yc, R, G, B);
  645.         setPixel (x + xc,y + yc, R, G, B);
  646.         if (d > 0){
  647.             yc  = yc-1;
  648.             dy -= aa2;
  649.             d  -= dy;
  650.         }
  651.         xc  =xc+1;
  652.         dx += bb2;
  653.         d  += bb + dx;
  654.     }
  655.     d += (3 * ((aa - bb) / 2) - (dx + dy) / 2);
  656.  
  657.     while (yc >= 0) {
  658.         setPixel (x - xc,y - yc, R, G, B);
  659.         setPixel (x - xc,y + yc, R, G, B);
  660.         setPixel (x + xc,y - yc, R, G, B);
  661.         setPixel (x + xc,y + yc, R, G, B);
  662.         if (d < 0) {
  663.             xc =xc+1;
  664.             dx += bb2;
  665.             d  += (bb + dx);
  666.         }
  667.         yc  = yc-1;
  668.         dy -= aa2;
  669.         d  += aa - dy;
  670.     }
  671.     SDL_Flip(screen);
  672. }
  673.  
  674. void setPixel(int x, int y, Uint8 R, Uint8 G, Uint8 B)
  675. {
  676.   if ((x>=0) && (x<width) && (y>=0) && (y<height))
  677.   {
  678.     /* Zamieniamy poszczególne składowe koloru na format koloru piksela */
  679.     Uint32 pixel = SDL_MapRGB(screen->format, R, G, B);
  680.  
  681.     /* Pobieramy informację ile bajtów zajmuje jeden piksel */
  682.     int bpp = screen->format->BytesPerPixel;
  683.  
  684.     /* Obliczamy adres piksela */
  685.     Uint8 *p1 = (Uint8 *)screen->pixels + (y*2) * screen->pitch + (x*2) * bpp;
  686.     Uint8 *p2 = (Uint8 *)screen->pixels + (y*2+1) * screen->pitch + (x*2) * bpp;
  687.     Uint8 *p3 = (Uint8 *)screen->pixels + (y*2) * screen->pitch + (x*2+1) * bpp;
  688.     Uint8 *p4 = (Uint8 *)screen->pixels + (y*2+1) * screen->pitch + (x*2+1) * bpp;
  689.  
  690.     /* Ustawiamy wartość piksela, w zależności od formatu powierzchni*/
  691.     switch(bpp)
  692.     {
  693.         case 1: //8-bit
  694.             *p1 = pixel;
  695.             *p2 = pixel;
  696.             *p3 = pixel;
  697.             *p4 = pixel;
  698.             break;
  699.  
  700.         case 2: //16-bit
  701.             *(Uint16 *)p1 = pixel;
  702.             *(Uint16 *)p2 = pixel;
  703.             *(Uint16 *)p3 = pixel;
  704.             *(Uint16 *)p4 = pixel;
  705.             break;
  706.  
  707.         case 3: //24-bit
  708.             if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
  709.                 p1[0] = (pixel >> 16) & 0xff;
  710.                 p1[1] = (pixel >> 8) & 0xff;
  711.                 p1[2] = pixel & 0xff;
  712.                 p2[0] = (pixel >> 16) & 0xff;
  713.                 p2[1] = (pixel >> 8) & 0xff;
  714.                 p2[2] = pixel & 0xff;
  715.                 p3[0] = (pixel >> 16) & 0xff;
  716.                 p3[1] = (pixel >> 8) & 0xff;
  717.                 p3[2] = pixel & 0xff;
  718.                 p4[0] = (pixel >> 16) & 0xff;
  719.                 p4[1] = (pixel >> 8) & 0xff;
  720.                 p4[2] = pixel & 0xff;
  721.             } else {
  722.                 p1[0] = pixel & 0xff;
  723.                 p1[1] = (pixel >> 8) & 0xff;
  724.                 p1[2] = (pixel >> 16) & 0xff;
  725.                 p2[0] = pixel & 0xff;
  726.                 p2[1] = (pixel >> 8) & 0xff;
  727.                 p2[2] = (pixel >> 16) & 0xff;
  728.                 p3[0] = pixel & 0xff;
  729.                 p3[1] = (pixel >> 8) & 0xff;
  730.                 p3[2] = (pixel >> 16) & 0xff;
  731.                 p4[0] = pixel & 0xff;
  732.                 p4[1] = (pixel >> 8) & 0xff;
  733.                 p4[2] = (pixel >> 16) & 0xff;
  734.             }
  735.             break;
  736.  
  737.         case 4: //32-bit
  738.             *(Uint32 *)p1 = pixel;
  739.             *(Uint32 *)p2 = pixel;
  740.             *(Uint32 *)p3 = pixel;
  741.             *(Uint32 *)p4 = pixel;
  742.             break;
  743.  
  744.     }
  745.          /* ewentualna aktualizacja obrazu (aka double buffering) */
  746.   }
  747. }
  748.  
  749. SDL_Color getPixel(int x, int y) {
  750.     SDL_Color color ;
  751.     Uint32 col = 0 ;
  752.     if ((x>=0) && (x<width) && (y>=0) && (y<height)) {
  753.         //określamy pozycję
  754.         char* pPosition=(char*)screen->pixels ;
  755.         //przesunięcie względem y
  756.         pPosition+=(screen->pitch*y*2) ;
  757.         //przesunięcie względem x
  758.         pPosition+=(screen->format->BytesPerPixel*x*2);
  759.         //kopiujemy dane piksela
  760.         memcpy(&col, pPosition, screen->format->BytesPerPixel);
  761.         //konwertujemy kolor
  762.         SDL_GetRGB(col, screen->format, &color.r, &color.g, &color.b);
  763.     }
  764.     return ( color ) ;
  765. }
  766.  
  767. SDL_Color getPixelSurface(int x, int y, SDL_Surface *surface) {
  768.     SDL_Color color ;
  769.     Uint32 col = 0 ;
  770.     //określamy pozycję
  771.     char* pPosition=(char*)surface->pixels ;
  772.     //przesunięcie względem y
  773.     pPosition+=(surface->pitch*y) ;
  774.     //przesunięcie względem x
  775.     pPosition+=(surface->format->BytesPerPixel*x);
  776.     //kopiujemy dane piksela
  777.     memcpy(&col, pPosition, surface->format->BytesPerPixel);
  778.     //konwertujemy kolor
  779.     SDL_GetRGB(col, surface->format, &color.r, &color.g, &color.b);
  780.     return ( color ) ;
  781. }
  782.  
  783. void czyscEkran(Uint8 R, Uint8 G, Uint8 B)
  784. {
  785.     SDL_FillRect(screen, 0, SDL_MapRGB(screen->format, R, G, B));
  786.     SDL_Flip(screen);
  787.  
  788. }
  789.  
  790. void ladujBMP(char const* nazwa, int x, int y)
  791. {
  792.     SDL_Surface* bmp = SDL_LoadBMP(nazwa);
  793.     if (!bmp)
  794.     {
  795.         printf("Unable to load bitmap: %s\n", SDL_GetError());
  796.     }
  797.     else
  798.     {
  799.         SDL_Rect dstrect;
  800.         dstrect.x = x;
  801.         dstrect.y = y;
  802.         SDL_Color kolor;
  803. //        SDL_BlitSurface(bmp, 0, screen, &dstrect);
  804.         for (int yy=0; yy<bmp->h; yy++) {
  805.  for (int xx=0; xx<bmp->w; xx++) {
  806.  kolor = getPixelSurface(xx, yy, bmp);
  807.  setPixel(xx, yy, kolor.r, kolor.g, kolor.b);
  808.  }
  809.         }
  810.  SDL_FreeSurface(bmp);
  811.         SDL_Flip(screen);
  812.     }
  813.  
  814. }
  815.  
  816.  
  817. int main ( int argc, char** argv )
  818. {
  819.     // console output
  820.     freopen( "CON", "wt", stdout );
  821.     freopen( "CON", "wt", stderr );
  822.  
  823.     // initialize SDL video
  824.     if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )
  825.     {
  826.         printf( "Unable to init SDL: %s\n", SDL_GetError() );
  827.         return 1;
  828.     }
  829.  
  830.     // make sure SDL cleans up before exit
  831.     atexit(SDL_Quit);
  832.  
  833.     // create a new window
  834.     screen = SDL_SetVideoMode(width*2, height*2, 32,
  835.                                            SDL_HWSURFACE|SDL_DOUBLEBUF);
  836.     if ( !screen )
  837.     {
  838.         printf("Unable to set video: %s\n", SDL_GetError());
  839.         return 1;
  840.     }
  841.  
  842.     SDL_WM_SetCaption( tytul , NULL );
  843.     // program main loop
  844.     bool done = false;
  845.     while (!done)
  846.     {
  847.         // message processing loop
  848.         SDL_Event event;
  849.         while (SDL_PollEvent(&event))
  850.         {
  851.             // check for messages
  852.             switch (event.type)
  853.             {
  854.                 // exit if the window is closed
  855.             case SDL_QUIT:
  856.                 done = true;
  857.                 break;
  858.  
  859.                 // check for keypresses
  860.             case SDL_KEYDOWN:
  861.                 {
  862.                     // exit if ESCAPE is pressed
  863.                     if (event.key.keysym.sym == SDLK_ESCAPE)
  864.                         done = true;
  865.                     if (event.key.keysym.sym == SDLK_1)
  866.                         Funkcja1();
  867.                     if (event.key.keysym.sym == SDLK_2)
  868.                         Funkcja2();
  869.                     if (event.key.keysym.sym == SDLK_3)
  870.                         Funkcja3();
  871.                     if (event.key.keysym.sym == SDLK_4)
  872.                         Funkcja4();
  873.                     if (event.key.keysym.sym == SDLK_5)
  874.                         Funkcja5();
  875.                     if (event.key.keysym.sym == SDLK_6)
  876.                         Funkcja6();
  877.                     if (event.key.keysym.sym == SDLK_7)
  878.                         Funkcja7();
  879.  
  880.                     if (event.key.keysym.sym == SDLK_a)
  881.                         ladujBMP("obrazek1a.bmp", 0, 0);
  882.                     if (event.key.keysym.sym == SDLK_s)
  883.                         ladujBMP("obrazek1b.bmp", 0, 0);
  884.                     if (event.key.keysym.sym == SDLK_d)
  885.                         ladujBMP("obrazek1c.bmp", 0, 0);
  886.                     if (event.key.keysym.sym == SDLK_f)
  887.                         ladujBMP("obrazek1d.bmp", 0, 0);
  888.                     if (event.key.keysym.sym == SDLK_z)
  889.                         ladujBMP("obrazek2a.bmp", 0, 0);
  890.                     if (event.key.keysym.sym == SDLK_x)
  891.                         ladujBMP("obrazek2b.bmp", 0, 0);
  892.                     if (event.key.keysym.sym == SDLK_c)
  893.                         ladujBMP("obrazek2c.bmp", 0, 0);
  894.                     if (event.key.keysym.sym == SDLK_v)
  895.                         ladujBMP("obrazek2d.bmp", 0, 0);
  896.                     if (event.key.keysym.sym == SDLK_n)
  897.                         ladujBMP("obrazek3a.bmp", 0, 0);
  898.                     if (event.key.keysym.sym == SDLK_m)
  899.                         ladujBMP("obrazek3b.bmp", 0, 0);
  900.  
  901.                     if (event.key.keysym.sym == SDLK_l)
  902.                         Linia(rand()%width, rand()%height, rand()%width, rand()%height, 100+rand()%155, 100+rand()%155, 100+rand()%155);
  903.                     if (event.key.keysym.sym == SDLK_o)
  904.                         Okrag(rand()%width, rand()%height, rand()%200, 100+rand()%155, 100+rand()%155, 100+rand()%155);
  905.                     if (event.key.keysym.sym == SDLK_e)
  906.                         Elipsa(rand()%width, rand()%height, rand()%200, rand()%200, 100+rand()%155, 100+rand()%155, 100+rand()%155);
  907.                     if (event.key.keysym.sym == SDLK_b)
  908.                         czyscEkran(0, 0, 10);          break;
  909.                      }
  910.             } // end switch
  911.         } // end of message processing
  912.  
  913.     } // end main loop
  914.  
  915.  
  916.     // all is well ;)
  917.     printf("Exited cleanly\n");
  918.     return 0;
  919. }
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!