SHARE
TWEET

Dithering

GieeF Jan 22nd, 2020 64 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  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. }
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