Lekcja 1.0.6 Allegro5 - bitmapy

                                                                       BITMAPY                            

LINK->Przykłady z kursu
W bibliotece allegro5 mamy możliwość wczytywania, wyświetlania jak i zapisu bitmap w wielu formatach: BMP,  PNG, JPG, PCX, TGA.
 Każdą wczytaną bitmapę możemy obracać o podany w radianach kąt, odwracać w poziomie i pionie, skalować, wycinać jej fragment, nadawać przezroczystość, jak i przemieszczać po ekranie.  Do tego celu mamy wiele funkcji graficznych.
Zanim jednak napiszę o wczytywaniu, wyświetlaniu i zapisie bitmap należy wspomnieć o możliwości  tworzenia własnych bitmap w pamięci, aby na przykład rysować, wyświetlać tekst na bitmapie, tworzyć warstwy bitmap,itd,itp.
                                                    TWORZENIE     BITMAP:                     
#include <allegro5/allegro.h> - wystarczy podstawowy nagłówek.
ALLEGRO_BITMAP *al_create_bitmap(int w, int h); // szerokość i wysokość bitmapy, liczby typu int.
Przykład:
ALLEGRO_BITMAP *kwadrat = al_create_bitmap(500,500); // tworzymy nową bitmapę o podanych wymiarach.
al_clear_to_color(al_map_rgb(0,120,0)); // nadajemy dany kolor bitmapie, jak i czyścimy podanym kolorem gdy chcemy usunąć wszystko co się na niej znajduje, aby było to możliwe musimy wskazać na nasz kwadrat. 
 al_set_target_bitmap(kwadrat); // rysujemy,piszemy na naszej bitmapie kwadrat.
Powrót do naszego okna - al_set_target_bitmap(al_get_backbuffer(okno)); lub al_set_target_backbuffer(okno);
                                                   WCZYTYWANIE     BITMAP:                  
#include <allegro5/allegro.h>                      
#include <allegro5/allegro_image.h> // plik nagłówkowy
#include <allegro5/allegro_native_dialog.h> // plik nagłówkowy do funkcji sprawdzającej wczytanie bitmapy.
 al_init_image_addon(); // inicjowanie bitmap, możliwości odczytu jak i zapisu bitmap.
 al_shutdown_image_addon(); //wyłączenie bitmap.
Wczytywanie bitmap:
ALLEGRO_BITMAP *bitmapa = al_load_bitmap("domek.png"); // ładowanie bitmapy w formacie png do pamięci, aby wczytać inny format zmieniamy rozszerzenie:....bmp,....jpg,....pcx,....tga.
if(!bitmapa) {
    al_show_native_message_box(okno, "Błąd", "Coś nie tak",
    "Nie mogę wczytać bitmapy domek!", NULL, ALLEGRO_MESSAGEBOX_ERROR);
     return 0;
    } // sprawdzenie czy bitmapa została poprawnie wczytana.

 Jeśli chcemy usunąć z pamięci daną bitmape dajemy   al_destroy_bitmap(bitmapa);
                                                               ZAPIS    BITMAP:                       
al_save_bitmap("ekran.png",al_get_backbuffer(okno)); //zapis całego ekranu, w różnych formatach, .png, .bmp, .jpg, .pcx, .tga. 
al_save_bitmap("zapis.png",bitmapa);// zapis wczytanej lub utworzonej bitmapy, w formatach jak wyżej. 
 if(al_key_down(&klawiatura,ALLEGRO_KEY_Z))al_save_bitmap("ekran.png",al_get_backbuffer(okno));
//zapis po wciśnięciu klawisza  Z 
                                               Kilka dodatkowych przydatnych funkcji:      
int al_get_bitmap_width(ALLEGRO_BITMAP *bitmapa) // pobranie szerokości danej bitmapy.
int al_get_bitmap_height(ALLEGRO_BITMAP *bitmapa) // pobranie wysokości danej bitmapy.
void al_convert_mask_to_alpha(ALLEGRO_BITMAP *bitmapa, ALLEGRO_COLOR mask_color)//kolor przezroczystości gdy brak go w obrazku(wybór dowolnego koloru)
ALLEGRO_BITMAP *al_clone_bitmap(ALLEGRO_BITMAP *owca) // tworzy kopie bitmapy.
ALLEGRO_BITMAP *al_create_sub_bitmap(ALLEGRO_BITMAP *rodzic, int x, int y, int w, int h);
// tworzy kopie bitmapy, lub jej fragment, x i y współrzędne na bitmapie źródłowej, w i h szerokość i
wysokość bitmapy docelowej.
ALLEGRO_COLOR al_get_pixel(ALLEGRO_BITMAP *bitmapa, int x, int y); // pobranie koloru piksela z podanej pozycji na bitmapie lub oknie, liczby typu int.
Przykłady:
int szerokosc = al_get_bitmap_width(bitmapa); // bitmapa bitmapa musi być wcześniej wczytana.
int wysokosc = al_get_bitmap_height(bitmapa); // bitmapa bitmapa musi być wcześniej wczytana.
al_convert_mask_to_alpha( bitmapa, al_map_rgb(255,0,255) );//nadanie przezroczystości bitmapie
ALLEGRO_BITMAP *dolly = al_clone_bitmap(owca); // bitmapa owca musi być wcześniej wczytana.
ALLEGRO_BITMAP *dziecko = al_create_sub_bitmap(rodzic,10, 12, 50, 60); // bitmapa rodzic musi być wcześniej wczytana, wymiary bitmapy docelowej(dziecko) mogą być większe od bitmapy źródłowej.
ALLEGRO_COLOR kolor = al_get_pixel(bitmapa,19, 68); // bitmapa bitmapa musi być wcześniej wczytana, lub ALLEGRO_COLOR kolor = al_get_pixel (al_get_backbuffer(okno),10,10);
----------------------------------------------------------------------------
Wyświetla piksel. 
al_draw_pixel( x,  y, kolor);
Parametry:
x, y                - pozycja bitmapy na ekranie (liczby typu float).
kolor             - kolor piksela (liczby typu float lub unsigned char).
Przykład: 
al_draw_pixel( 5, 5, al_map_rgb(255, 255, 255));
--------------------------------------------------------------- 
Wyświetla bitmapę. 
al_draw_bitmap(bitmapa, dx, dy, flaga);
Parametry:
bitmapa        -  ALLEGRO_BITMAP *bitmapa
dx, dy           - pozycja bitmapy na ekranie. (liczby typu float).
flaga             -  odwracanie bitmapy, 0, 1, 2, 3 (liczba typu int). lub
ALLEGRO_FLIP_VERTICAL      - odwrócenie w osi x.
ALLEGRO_FLIP_HORIZONTAL - odwrócenie w osi y.

Przykład:
al_draw_bitmap (bitmapa,10,10,ALLEGRO_FLIP_VERTICAL | ALLEGRO_FLIP_HORIZONTAL); // lub 3 
------------------------------------------------------------------------ 
 Wyświetla skalowalną bitmapę. 
al_draw_scaled_bitmap(bitmapa, sx, sy, sw, sh, dx, dy, dw, dh, flaga);
Parametry:
bitmapa             -  ALLEGRO_BITMAP *bitmapa
sx,sy                   - pozycja początkowa w osi x i y na bitmapie od której ma być wyświetlana bitmapa docelowa (liczby typu float).
sw,sh                 - szerokość i wysokość z bitmapy żródłowej w pikselach (liczby typu float).
dx, dy                - pozycja bitmapy na ekranie. (liczby typu float).
dw, dh               - wielkość wyświetlanej bitmapy wyrażona w pikselach (liczby typu float). 
flaga                  - jak w  al_draw_bitmap.
Przykład:
al_draw_scaled_bitmap(bitmapa,15,10,90,90,150,10,128,128,1);
------------------------------------------------------------------------
Wyświetla obracalną bitmapę. 
al_draw_rotated_bitmap(bitmapa, cx, cy, dx, dy, kat, flaga);
Parametry:
bitmapa     -  ALLEGRO_BITMAP *bitmapa
cx,cy          -  pozycja w osi x i y na bitmapie, względem której ma być obracana bitmapa.(liczby typu float).
dx, dy       - pozycja bitmapy na ekranie. (liczby typu float).
kat             - kąt obrotu w prawo podany radianach. (liczba typu float).
flaga         - jak w  al_draw_bitmap.
Przykład:
al_draw_rotated_bitmap(bitmapa, 64, 64,350, 74, 3.14/4, 0);
----------------------------------------------------------------------
 Wyświetla wycinek  bitmapy.
al_draw_bitmap_region(bitmapa, sx, sy, sw, sh, dx, dy, flaga); 
Parametry: 
bitmapa   -  ALLEGRO_BITMAP *bitmapa
sx,sy        - pozycja x i y na bitmapie źródłowej.(liczby typu float).
sw,sh       - szerokość i wysokość bitmapy docelowej.(liczby typu float).
dx, dy      - pozycja bitmapy docelowej na ekranie. (liczby typu float). 
flaga        - jak w  al_draw_bitmap.
Przykład:
al_draw_bitmap_region(bitmapa,64,0,64, 64, 520, 60, 0);
-----------------------------------------------------------------------
Wyświetla skalowalną i obracalną bitmapę. 
al_draw_scaled_rotated_bitmap(bitmapa, cx, cy, dx, dy, skalax, skalay, kat, flaga); 
Parametry:
bitmapa     -  ALLEGRO_BITMAP *bitmapa
cx,cy          -  pozycja w osi x i y na bitmapie, względem której ma być obracana bitmapa.(liczby typu float).
dx, dy       - pozycja bitmapy na ekranie. (liczby typu float).
skalax, skalay - wielkość bitmapy. (liczby typu float).1 to normalna wielkość,2 to dwa razy większa.
kat            - kąt obrotu w prawo podany radianach. (liczba typu float).
flaga        - jak w  al_draw_bitmap.
Przykład:
al_draw_scaled_rotated_bitmap(bitmapa, 64, 64,90,225, 0.8,1.2,3.14/3,0);
----------------------------------------------------------------------
Wyświetla bitmapę ze zmianą przejrzystości i jasności kolorów. 

al_draw_tinted_bitmap(bitmapa, kolor, dx, dy, flaga); 

Parametry: 
bitmapa      -  ALLEGRO_BITMAP *bitmapa 
kolor           - al_map_rgba_f( 1.0, 1.0, 1.0, 0,5); - liczby typu  float lub unsigned char.(rgb, rgba, rgb_f, rgba_f)..-skala jasności kolorów i przejrzystości tu: RGB-100%, alfa-50%

                            (1.0,1.0,1.0,1.0)          (1.0,0.0,0.0,1.0)          (0.0,1.0,0.0,1.0)         (0.0,0.0,1.0,1.0)
Podane są tu skrajne wartości, choć mogą być z zakresu 0.0...1.0(float), lub 0...255(unsigned char) 
dx, dy            - pozycja bitmapy na ekranie. (liczby typu float). 
flaga               - jak w  al_draw_bitmap. 
Przykład: 
al_draw_tinted_bitmap(bitmapa,al_map_rgba_f (1.0, 1.0, 1.0, 0.5), 160, 130, 1);
-----------------------------------------------------------
Wyświetla skalowalną bitmapę ze zmianą przejrzystości i jasności kolorów.
al_draw_tinted_scaled_bitmap(bitmapa, kolor, sx, sy, sw, sh, dx, dy, dw, dh, flaga); 

Parametry: 

bitmapa              -  ALLEGRO_BITMAP *bitmapa

kolor                   - jak w  al_draw_tinted_bitmap

sx,sy                   - pozycja początkowa w osi x i y na bitmapie od której ma być wyświetlana bitmapa docelowa (liczby typu float).
sw,sh                 - szerokość i wysokość z bitmapy źródłowej w pikselach (liczby typu float). 
dx, dy                - pozycja bitmapy na ekranie. (liczby typu float). 
dw, dh               - wielkość wyświetlanej bitmapy wyrażona w pikselach (liczby typu float). 
flaga                  - jak w  al_draw_bitmap. 
Przykład: 
al_draw_tinted_scaled_bitmap(bitmapa, al_map_rgba_f (0.5,0.5,0.0,0.4), 10, 20, 100, 80, 300, 150, 100, 100, 0);
-------------------------------------------------------- 
Wyświetla wycinek  bitmapy ze zmianą przejrzystości i jasności kolorów.
 al_draw_tinted_bitmap_region(bitmapa, kolor, sx, sy, sw, sh, dx, dy, flaga); 
 Parametry: 
 bitmapa      -  ALLEGRO_BITMAP *bitmapa
 kolor           - jak w  al_draw_tinted_bitmap
 sx,sy           - pozycja początkowa w osi x i y na bitmapie od której ma być wyświetlana bitmapa docelowa (liczby typu float).
 sw,sh         - szerokość i wysokość bitmapy docelowej.(liczby typu float).
 dx, dy        - pozycja bitmapy na ekranie. (liczby typu float). 
 flaga          - jak w  al_draw_bitmap.
 Przykład:
 al_draw_tinted_bitmap_region(bitmapa, al_map_rgba_f (0.8,0.2,0.8,0.2), 0, 20, 128, 80, 450, 160,0);
  --------------------------------------------------------
Wyświetla obracalną bitmapę ze zmianą przejrzystości i jasności kolorów.
al_draw_tinted_rotated_bitmap(bitmapa, kolor,cx, cy, dx, dy, kat, flaga);
Parametry: 
bitmapa    -  ALLEGRO_BITMAP *bitmapa
kolor         - jak w  al_draw_tinted_bitmap
cx,cy         -  pozycja w osi x i y na bitmapie docelowej, względem której ma być obracana bitmapa.(liczby typu float).
dx, dy       - pozycja bitmapy na ekranie. (liczby typu float).
kat             - kąt obrotu w prawo podany radianach. (liczba typu float).
flaga         - jak w  al_draw_bitmap.
Przykład:
al_draw_tinted_rotated_bitmap (bitmapa, al_map_rgba_f (1.0, 1.0, 0.0, 0.5), 64, 64, 90, 350, 1.2, 0);
--------------------------------------------------------------------
Wyświetla obracalną, skalowalną bitmapę ze zmianą przejrzystości i jasności kolorów.
al_draw_tinted_scaled_rotated_bitmap(bitmapa, kolor,cx, cy, dx, dy, skalax, skalay, kat, flaga);
Parametry: 
bitmapa     -  ALLEGRO_BITMAP *bitmapa
kolor          - jak w  al_draw_tinted_bitmap
cx,cy          -  pozycja w osi x i y na bitmapie docelowej, względem której ma być obracana bitmapa.(liczby typu float).
dx, dy        - pozycja bitmapy na ekranie. (liczby typu float).
skalax, skalay - wielkość bitmapy. (liczby typu float).1 to normalna wielkość,2 to dwa razy większa.
kat             - kąt obrotu w prawo podany radianach. (liczba typu float).
flaga          - jak w  al_draw_bitmap.
Przykład:
al_draw_tinted_scaled_rotated_bitmap(bitmapa, al_map_rgba_f (1.0, 1.0, 1.0, 0.6), 64, 64, 310, 350, 1.5, 1.5, 1.1, 0);
---------------------------------------------------------------------
Wyświetla wycinek bitmapy, obracalny, skalowalny ze zmianą przejrzystości i jasności kolorów.
al_draw_tinted_scaled_rotated_bitmap_region(bitmapa, sx, sy, sw, sh, kolor, cx, cy, dx, dy, skalax, skalay, kat, flaga);
Parametry: 
bitmapa     -  ALLEGRO_BITMAP *bitmapa
sx,sy          - pozycja początkowa w osi x i y na bitmapie od której ma być wyświetlana bitmapa docelowa (liczby typu float).
sw,sh         - szerokość i wysokość bitmapy docelowej.(liczby typu float).
kolor          - jak w  al_draw_tinted_bitmap
cx,cy          -  pozycja w osi x i y na bitmapie docelowej, względem której ma być obracana bitmapa.(liczby typu float).
dx, dy        - pozycja bitmapy na ekranie. (liczby typu float).
skalax, skalay - wielkość bitmapy. (liczby typu float).1 to normalna wielkość,2 to dwa razy większa.
kat             - kąt obrotu w prawo podany radianach. (liczba typu float).
flaga          - jak w  al_draw_bitmap.
Przykład:
al_draw_tinted_scaled_rotated_bitmap_region(bitmapa,10,10,110,110, al_map_rgba_f (1.0, 1.0, 1.0, 0.6), 64, 64, 480, 360, 1.9,1.9, 1.4, 0);
---------------------------------------------------------------------
 Przykładowy kod:
#include <allegro5/allegro.h>
#include <allegro5/allegro_image.h>
int main()
{
    al_init();
    al_install_keyboard();
    al_init_image_addon();
    ALLEGRO_KEYBOARD_STATE klawiatura;
    ALLEGRO_DISPLAY  *okno  = al_create_display(640, 480);
    al_set_window_title( okno, "Bitmapy");
    ALLEGRO_BITMAP  *bitmapa = al_load_bitmap( "domek.png" );//Wczytywanie obrazka
  //kolor przezroczystości gdy brak go w obrazku(wybór dowolnego koloru)
  //al_convert_mask_to_alpha( bitmapa, al_map_rgb(255,0,255) );
    ALLEGRO_EVENT_QUEUE *event_queue = al_create_event_queue();
    al_register_event_source(event_queue, al_get_display_event_source(okno));
    ALLEGRO_EVENT event;
    while(!al_key_down(&klawiatura, ALLEGRO_KEY_ESCAPE))
    {
     al_get_next_event(event_queue, &event); if(event.type == ALLEGRO_EVENT_DISPLAY_CLOSE) return 0;
     al_get_keyboard_state(&klawiatura);
     al_clear_to_color(al_map_rgb(128,128,128));//kolor okna
     al_draw_pixel( 5, 5, al_map_rgb(255,255,255));
     al_draw_bitmap (bitmapa, 10, 10, 0);
     al_draw_scaled_bitmap(bitmapa, 15, 10, 90, 90, 150, 10, 128, 128, 1);
     al_draw_rotated_bitmap(bitmapa, 64, 64, 370, 74, 3.14/4, 0);
     al_draw_bitmap_region(bitmapa, 64, 0, 64, 64, 520, 60, 0);
     al_draw_scaled_rotated_bitmap(bitmapa, 64, 64, 90, 225, 0.8, 1.2, 3.14/3, 0);
     al_draw_tinted_bitmap(bitmapa,al_map_rgba_f (1.0, 1.0, 1.0, 0.5), 160, 130, 1);
     al_draw_tinted_scaled_bitmap(bitmapa, al_map_rgba_f (0.5,0.5,0.0,0.4), 10, 20, 100, 80, 300, 150, 100, 100, 0);
     al_draw_tinted_bitmap_region(bitmapa, al_map_rgba_f (0.8,0.2,0.8,0.2), 0, 20, 128, 80, 450, 160, 0);
     al_draw_tinted_rotated_bitmap(bitmapa, al_map_rgba_f (1.0, 1.0, 0.0, 0.5), 64, 64, 90, 350, 1.2, 0);
     al_draw_tinted_scaled_rotated_bitmap(bitmapa, al_map_rgba_f (1.0, 1.0, 1.0, 0.6), 64, 64, 310, 350, 1.5, 1.5, 1.1, 0);
 al_draw_tinted_scaled_rotated_bitmap_region(bitmapa,10,10,110,110,al_map_rgba_f(1,1,1, 0.6), 64,64,480,360,1.9,1.9,1.4,0);
      al_flip_display();
      al_rest(0.001);//pauza
    }
    al_save_bitmap("ekran.png",al_get_backbuffer(okno)); // zrzut ekranu do formatu png.
    al_save_bitmap("zapis.bmp",bitmapa); //  zapis nastąpi przy zamykaniu programu
    al_save_bitmap("zapis.png",bitmapa); //  klawiszem escape, a nie przyciskiem zamykania X.
    al_save_bitmap("zapis.jpg",bitmapa);
    al_save_bitmap("zapis.pcx",bitmapa);
    al_save_bitmap("zapis.tga",bitmapa);
    al_destroy_display(okno);
    al_destroy_bitmap (bitmapa);
    return 0;
}


Aby wygładzić krawędzie i piksele bitmap przed ich wczytywaniem dodajemy funkcje:
al_set_new_bitmap_flags ( ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR);

    4x