Ve čtrnácté části seriálu o programovacích jazycích i o knihovnách a frameworcích vhodných pro výuku programování popř. pro výuku základů počítačové grafiky, si popíšeme, jak je v knihovně Pygame možné provádět lineární transformace rastrových obrázků, tj. jak lze obrázky převracet, zvětšovat, zmenšovat či otáčet.

Obsah

1. Programovací jazyky a knihovny určené pro výuku základů počítačové grafiky: transformace rastrových obrázků

2. Horizontální a vertikální zrcadlení obrázku

3. Zdrojový kód demonstračního příkladu pygame25: použití transformace pygame.transform.flip()

4. Rychlý algoritmus pro změnu měřítka obrázku

5. Zdrojový kód demonstračního příkladu pygame26: použití transformace pygame.transform.scale()

6. Optimalizovaný algoritmus pro změnu obrázku s aplikací bilineárního filtru

7. Zdrojový kód demonstračního příkladu pygame27: rozdíl mezi pygame.transform.scale() a pygame.transform.smoothscale()

8. Rotace obrázku

9. Rotace obrázku současně se změnou měřítka

10. Zdrojový kód demonstračního příkladu pygame28: operace pygame.transform.rotate() a pygame.transform.rotozoom()

11. Obsah následující části seriálu

12. Repositář se zdrojovými kódy všech dnešních demonstračních příkladů

13. Funkce použité v dnešních demonstračních příkladech

14. Odkazy na Internetu

1. Programovací jazyky a knihovny určené pro výuku základů počítačové grafiky: transformace rastrových obrázků

V dnešní části seriálu o programovacích jazycích a taktéž o knihovnách určených (nejenom) pro výuku počítačové grafiky, se opět seznámíme s některými funkcemi a metodami nabízenými knihovnou Pygame. V předchozích částech jsme se dozvěděli, jakým způsobem je možné načítat rastrové obrázky z externích souborů, kombinovat obrázky mezi sebou s využitím rastrových operací (raster ops) popř. jak lze z těchto obrázků vytvářet pohybující se sprity. Taktéž umíme do obrázků vykreslovat základní geometrické tvary popř. i písmo. Ovšem k plnému využití všech možností nabízených knihovnou Pygame je nutné se seznámit s modulem nazvaným pygame.transform. Tento modul programátorům nabízí několik funkcí určených pro provádění takzvaných lineárních transformací rastrových obrázků. Co to znamená v praxi? Obrázky je možné převracet (horizontálně či vertikálně), zvětšovat je, zmenšovat je a samozřejmě taktéž otáčet. Všechny tyto funkce, které jsou definovány v modulu pygame.transform, vždy vedou k vytvoření nového obrázku, tj. původní obrázek zůstává nezměněn.

08

Obrázek 1: Z předchozího článku: kolize hráče s jiným (nepohyblivým) spritem.

2. Horizontální a vertikální zrcadlení obrázku

První lineární transformací, s níž se dnes setkáme, je transformace, která vede k převrácení (zrcadlení) zvoleného rastrového obrázku, a to buď horizontálně, vertikálně, nebo současně horizontálně i vertikálně. Tato transformace je zajímavá tím, že nově vzniklý obrázek bude mít stejné rozměry, jako měl obrázek původní, protože zrcadlení je osově či středově symetrické. Pokud budete potřebovat vytvořit zrcadlový obraz nějaké bitmapy, stačí použít funkci nazvanou pygame.transform.flip(), jejíž podrobnější popis naleznete na adrese http://www.pygame.org/docs/ref/transform.html#pygame.transform.flip. Této funkci je nutné v prvním parametru předat referenci na zdrojový obrázek, druhý parametr určuje, zda se má provést horizontální zrcadlení (False=neprovádět, True=provádět) a konečně třetím parametrem se řídí vertikální zrcadlení (opět: False=neprovádět, True=provádět). Zdrojový obrázek zůstává nezměněn, cílový obrázek je vrácen jako výsledná hodnota volané funkce.

01

Obrázek 2: Screenshot získaný z dnešního prvního demonstračního příkladu.

3. Zdrojový kód demonstračního příkladu pygame25: použití transformace pygame.transform.flip()

Ve druhé kapitole popsaná transformace pygame.transform.flip() je použita v dnešním prvním demonstračním příkladu pojmenovaném pygame25. Po spuštění tohoto příkladu je otevřeno okno o velikosti 320×240 pixelů, následně je načten obrázek představující logo knihovny Pygame a posléze jsou z tohoto obrázku s využitím pygame.transform.flip() vytvořeny tři zrcadlové kopie. První kopie vzniká zrcadlením původního rastrového obrázku podle svislé osy, druhá zrcadlením podle vodorovné osy a třetí kopie zrcadlením okolo obou os (nebo okolo středu). Všechny čtyři obrázky jsou následně vykresleny do plochy okna s využitím nám již známé a již častěji použité funkce pygame.Surface.blit():

#!/usr/bin/python
# vim: set fileencoding=utf-8

# Demonstrační příklady využívající knihovnu Pygame

# Příklad číslo 25: použití objektů typu Surface, metoda blit()
#                   a operace pygame.transform.flip().


import pygame, sys, os

# Nutno importovat kvůli konstantám QUIT atd.
from pygame.locals import *

# Velikost okna aplikace
WIDTH = 320
HEIGHT = 240

# Inicializace knihovny Pygame 
pygame.init()

clock = pygame.time.Clock()

# Vytvoření okna pro vykreslování
display = pygame.display.set_mode([WIDTH, HEIGHT])

# Nastavení titulku okna
pygame.display.set_caption('Pygame test #25')

# Konstanty s n-ticemi představujícími základní barvy
BLACK   = (  0,   0,   0)

# Vyplnění plochy okna černou barvou
display.fill(BLACK)

# Načtení obrázku, který se bude vykreslovat a transformovat
image_surface = pygame.image.load(os.path.join('images', 'pygame.png'))

# Vytvoření zrcadlených obrázků
horizontally_flipped = pygame.transform.flip(image_surface, True, False)
vertically_flipped   = pygame.transform.flip(image_surface, False, True)
both_flipped   = pygame.transform.flip(image_surface, True, True)

# Přímé vykreslení původního obrázku
display.blit(image_surface, (50, 25))

# Přímé vykreslení zrcadlených obrázků
display.blit(horizontally_flipped, (150, 25))
display.blit(vertically_flipped, (50, 125))
display.blit(both_flipped, (150, 125))



# Hlavní herní smyčka
while True:
    # Načtení a zpracování všech událostí z fronty
    for event in pygame.event.get():
        # Uzavřením okna běh aplikace ukončí
        if event.type == QUIT:
            pygame.quit()
            sys.exit()
        # Klávesou ESC se běh aplikace ukončí
        if event.type == KEYDOWN and event.key == K_ESCAPE:
            pygame.quit()
            sys.exit()

    pygame.display.update()
    clock.tick(20)

# finito

4. Rychlý algoritmus pro změnu měřítka obrázku

Druhou lineární transformací, s níž se v praxi setkáte pravděpodobně mnohem častěji, než se zrcadlením, je transformace určená pro změnu měřítka obrázku, tj. pro jeho zvětšení nebo zmenšení. Zajímavé je, že změnu měřítka je možné provádět v horizontálním směru nezávisle na směru vertikálním, což například znamená, že zdrojovou bitmapu lze v jednom směru zvětšit a ve druhém zmenšit, natahovat či naopak zmenšovat obrázek jen ve směru vodorovné osy atd. Zatímco mnoho grafických knihoven, které tuto lineární transformaci podporují, používá pro specifikaci zvětšení či zmenšení jedno reálné číslo (hodnota menší než jedna potom značí zmenšení, hodnota větší než jedna naopak zvětšení, jednička představuje identitu), je tomu v knihovně Pygame jinak, protože programátor může zadat přímo rozlišení (šířku a výšku) výsledné bitmapy.

02

Obrázek 3: Screenshot druhého demonstračního příkladu, koeficient změny měřítka původní bitmapy byl nastaven na hodnotu 1,5.

Pro změnu měřítka je v této knihovně určena funkce nazvaná pygame.transform.scale(), které se v prvním parametru předá zdrojová bitmapa (která se nezmění) a ve druhém parametru dvojice hodnot představujících šířku a výšku. Výsledkem funkce pygame.transform.scale() bude nová bitmapa s požadovanými rozměry. Dejte si pozor na to, že obě hodnoty musí být celá čísla, což znamená, že se většinou musí provést zaokrouhlení. Přesně tuto operaci provedeme i my v demonstračním příkladu, protože velikost výsledné bitmapy vypočteme na základě rozměrů původní bitmapy a koeficientu zvětšení (kterým bude reálné číslo).

03

Obrázek 4: Screenshot druhého demonstračního příkladu, koeficient změny měřítka původní bitmapy byl nastaven na hodnotu 0,7.

5. Zdrojový kód demonstračního příkladu pygame26: použití transformace pygame.transform.scale()

Funkci pygame.transform.scale() popsanou ve čtvrté kapitole použijeme v dnešním druhém demonstračním příkladu, jehož základní kostra je prakticky shodná s příkladem předchozím. I zde se tedy nejprve otevře okno s plochou o velikosti minimálně 320×240 pixelů, načte se zdrojový obrázek a následně se nad tímto obrázkem provedou tři zvolené lineární transformace: zmenšení/zvětšení v horizontálním směru, zmenšení/zvětšení ve vertikálním směru a zmenšení/zvětšení se stejným koeficientem v obou směrech. Míra zmenšení či zvětšení je řízena hodnotou konstanty pojmenované scale_ratio. Na základě hodnoty této konstanty a rozlišení původního obrázku se vypočtou požadované velikosti všech tří cílových (transformovaných) bitmap, které jsou následně vykresleny na obrazovku:

#!/usr/bin/python
# vim: set fileencoding=utf-8

# Demonstrační příklady využívající knihovnu Pygame

# Příklad číslo 26: použití objektů typu Surface, metoda blit()
#                   a operace pygame.transform.scale().


import pygame, sys, os

# Nutno importovat kvůli konstantám QUIT atd.
from pygame.locals import *

# Velikost okna aplikace
WIDTH = 320
HEIGHT = 240

# Inicializace knihovny Pygame 
pygame.init()

clock = pygame.time.Clock()

# Vytvoření okna pro vykreslování
display = pygame.display.set_mode([WIDTH, HEIGHT])

# Nastavení titulku okna
pygame.display.set_caption('Pygame test #26')

# Konstanty s n-ticemi představujícími základní barvy
BLACK   = (  0,   0,   0)

# Vyplnění plochy okna černou barvou
display.fill(BLACK)


# Načtení obrázku, který se bude vykreslovat a transformovat
image_surface = pygame.image.load(os.path.join('images', 'pygame.png'))

# Rozměry původního obrázku
image_width  = image_surface.get_width()
image_height = image_surface.get_height()

scale_ratio = 1.5

# Vytvoření zvětšených obrázků
horizontally_scaled_image = pygame.transform.scale(image_surface, (int(image_width*scale_ratio), image_height))
vertically_scaled_image   = pygame.transform.scale(image_surface, (image_width, int(image_height*scale_ratio)))
scaled_image              = pygame.transform.scale(image_surface, (int(image_width*scale_ratio), int(image_height*scale_ratio)))

# Přímé vykreslení původního obrázku
display.blit(image_surface, (50, 25))

# Přímé vykreslení zvětšených obrázků
display.blit(horizontally_scaled_image, (150, 25))
display.blit(vertically_scaled_image, (50, 125))
display.blit(scaled_image, (150, 125))



# Hlavní herní smyčka
while True:
    # Načtení a zpracování všech událostí z fronty
    for event in pygame.event.get():
        # Uzavřením okna běh aplikace ukončí
        if event.type == QUIT:
            pygame.quit()
            sys.exit()
        # Klávesou ESC se běh aplikace ukončí
        if event.type == KEYDOWN and event.key == K_ESCAPE:
            pygame.quit()
            sys.exit()

    pygame.display.update()
    clock.tick(20)

# finito

6. Optimalizovaný algoritmus pro změnu obrázku s aplikací bilineárního filtru

Pokud jste se pozorně podívali na výsledek předchozího demonstračního příkladu, v němž se obrázky zvětšují či zmenšují s využitím funkce pygame.transform.scale(), pravděpodobně jste si všimli nepříjemného jevu: při zvětšování se začínají objevovat velké „kostičky“ vzniklé zvětšením původních pixelů. Algoritmus, na němž je funkce pygame.transform.scale() postavena, je totiž navržen takovým způsobem, aby byl co nejrychlejší a aby se současně zbytečně nezvětšovala bitová hloubka cílové bitmapy (to platí ve chvíli, kdy má zdrojová bitmapa barvovou paletu a tedy maximálně 256 barev či když je použita hloubka 16bpp, což je typické pro poměrně velké množství her). Proto do výsledné bitmapy nejsou přidávány žádné nové barvy, ale dochází „jen“ k výběru barev z původních pixelů. Podívejme se na výsledek zvětšení ve chvíli, kdy je koeficient zvětšení nastaven na skutečně vysokou hodnotu. „Kostičky“ jsou zde jasně patrné:

04

Obrázek 5: Zvětšení bitmapy s využitím operace pygame.transform.scale().

V případě, že je ve vytvářené aplikaci zapotřebí, aby se při zvětšování používaly výkonnější filtry, většinou takzvaná bilineární filtrace, je nutné namísto rychlé funkce pygame.transform.scale() použít poněkud pomalejší funkci nazvanou příhodně pygame.transform.smoothscale(). Obě funkce akceptují stejné parametry (zdrojovou bitmapu a rozměry cílového obrázku), ovšem díky bilineární filtraci dává funkce pygame.transform.smoothscale() vizuálně lepší výsledky. Za vyšší kvalitu platíme pomalejším algoritmem a taktéž tím, že výsledná bitmapa bude mít vždycky hloubku 24bpp, což v některých případech znamená nutnost změny barevné hloubky takovým způsobem, aby formát bitmapy byl kompatibilní s formátem framebufferu. Z tohoto důvodu je vhodné si všechny bitmapy připravit ještě před vstupem do hlavní (herní) smyčky.

05

Obrázek 6: Zvětšení bitmapy s využitím operace pygame.transform.smoothscale().

7. Zdrojový kód demonstračního příkladu pygame27: rozdíl mezi pygame.transform.scale() a pygame.transform.smoothscale()

Dnešní třetí demonstrační příklad nazvaný pygame27 je založen na zdrojovém kódu příkladu druhého, protože i zde se používá lineární transformace pro zvětšení původní bitmapy v horizontálním směru, vertikálním směru i v obou směrech současně. V příkladu jsou použity obě funkce pro změnu měřítka, tj. jak pygame.transform.scale(), tak i pygame.transform.smoothscale(), takže na výsledném screenshotu je dobře patrné, jak se liší výsledné bitmapy vytvořené oběma funkcemi. V levém horním rohu je původní bitmapa, napravo od ní pak bitmapy vzniklé zvětšením v horizontálním směru, vlevo dole bitmapy vzniklé zvětšením vertikálním a konečně v pravém dolním rohu je obrázek zvětšen v obou směrech. Navíc se ještě do volného místa vypisuje technologie použitá funkcí pygame.transform.smoothscale(). Tu lze zjistit přes pygame.transform.get_smoothscale_backend().

06

Obrázek 7: Screenshot dnešního třetího demonstračního příkladu.

#!/usr/bin/python
# vim: set fileencoding=utf-8

# Demonstrační příklady využívající knihovnu Pygame

# Příklad číslo 27: použití objektů typu Surface, metoda blit()
#                   a operace pygame.transform.smoothscale().


import pygame, sys, os

# Nutno importovat kvůli konstantám QUIT atd.
from pygame.locals import *

# Velikost okna aplikace
WIDTH = 400
HEIGHT = 400

# Inicializace knihovny Pygame 
pygame.init()

clock = pygame.time.Clock()

# Vytvoření okna pro vykreslování
display = pygame.display.set_mode([WIDTH, HEIGHT])

# Nastavení titulku okna
pygame.display.set_caption('Pygame test #27')

# Konstanty s n-ticemi představujícími základní barvy
BLACK   = (  0,   0,   0)

# Vyplnění plochy okna černou barvou
display.fill(BLACK)


# Načtení obrázku, který se bude vykreslovat a transformovat
image_surface = pygame.image.load(os.path.join('images', 'pygame.png'))

# Rozměry původního obrázku
image_width  = image_surface.get_width()
image_height = image_surface.get_height()

scale_ratio = 3

# Vytvoření zvětšených obrázků
horizontally_scaled_image        = pygame.transform.scale(image_surface, (int(image_width*scale_ratio), image_height))
horizontally_smooth_scaled_image = pygame.transform.smoothscale(image_surface, (int(image_width*scale_ratio), image_height))
vertically_scaled_image          = pygame.transform.scale(image_surface, (image_width, int(image_height*scale_ratio)))
vertically_smooth_scaled_image   = pygame.transform.smoothscale(image_surface, (image_width, int(image_height*scale_ratio)))
smooth_scaled_image              = pygame.transform.smoothscale(image_surface, (int(image_width*scale_ratio), int(image_height*scale_ratio)))

# Přímé vykreslení původního obrázku
display.blit(image_surface, (10, 10))

# Přímé vykreslení zvětšených obrázků
display.blit(horizontally_scaled_image, (170, 10))
display.blit(horizontally_smooth_scaled_image, (170, 90))
display.blit(vertically_scaled_image, (10, 170))
display.blit(vertically_smooth_scaled_image, (90, 170))
display.blit(smooth_scaled_image, (170, 170))

# Načtení fontu (zadává se soubor se jménem fontu a velikost
font = pygame.font.Font("fonts/FreeSans.ttf", 40)

WHITE   = (255, 255, 255)
RED     = (255,   0,   0)
# Vytvoření obrázku s vykresleným textem
# - první parametr obsahuje řetězec, který se má vykreslit
# - druhý parametr řídí použití antialiasingu
# - třetí parametr volí barvu fontu
font_surface1 = font.render(pygame.transform.get_smoothscale_backend(), True, WHITE, RED)

# Vykreslení obrázku s nápisem do bufferu
display.blit(font_surface1, (15, 100))



# Hlavní herní smyčka
while True:
    # Načtení a zpracování všech událostí z fronty
    for event in pygame.event.get():
        # Uzavřením okna běh aplikace ukončí
        if event.type == QUIT:
            pygame.quit()
            sys.exit()
        # Klávesou ESC se běh aplikace ukončí
        if event.type == KEYDOWN and event.key == K_ESCAPE:
            pygame.quit()
            sys.exit()

    pygame.display.update()
    clock.tick(20)

# finito

8. Rotace obrázku

Konečně se dostáváme ke třetí a interně nejsložitější lineární transformaci. Tou je rotace obrázku. Složitost této transformace spočívá v tom, že je zapotřebí správně vypočítat rozměry výsledného obrázku, a to pro jakoukoli rotaci (nejenom tedy pro rotaci o 90°, 180° a 270°, kde je výpočet triviální). Následně musí dojít k přepočtu všech pixelů cílového obrázku na základě mapování mezi lokálním souřadnicovým systémem zdrojové bitmapy a odlišným lokálním souřadnicovým systémem bitmapy cílové. Rotaci lze v knihovně Pygame provést s využitím funkce nazvané pygame.transform.rotate(). Této funkci se předá reference na zdrojovou bitmapu (ta opět není změněna) a úhel otáčení specifikovaný ve stupních. Pokud je úhel otáčení nastaven na 90°, 180° či 270°, je při výpočtu použit rychlý algoritmus, v případě zadání odlišného úhlu bude algoritmus složitější a nepatrně pomalejší. To opět vede k doporučení vypočítat si všechny varianty bitmap ještě před vstupem do hlavní programové smyčky.

9. Rotace obrázku současně se změnou měřítka

Zajímavé je, že knihovna Pygame obsahuje i funkci nazvanou pygame.transform.rotozoom(), která kombinuje dvě lineární transformace: změnu měřítka a rotaci bitmapy. V tomto případě se změna měřítka specifikuje reálným číslem, přičemž hodnota menší než 1 značí zmenšení a hodnota větší než 1 naopak zvětšení bitmapy. Rotace se stále specifikuje ve stupních. Funkci pygame.transform.rotozoom() se předává trojice parametrů: reference na zdrojovou bitmapu, požadovaný úhel otočení bitmapy a míra zvětšení či zmenšení. To mj. znamená, že již není možné bitmapu nezávisle zmenšovat/zvětšovat ve směru vertikální a horizontální osy. To by ostatně bylo problematické i z hlediska chápání chování funkce rotozoom: pokud je změna měřítka v obou směrech stejná, nezáleží na tom, zda se rotace provede dříve než otočení či naopak. Při změně měřítka se používá pomalejší algoritmus, než u funkce pygame.transform.scale(), což je ostatně patrné i při pohledu na poslední screenshot:

07

Obrázek 8: Screenshot dnešního čtvrtého demonstračního příkladu.

10. Zdrojový kód demonstračního příkladu pygame28: operace pygame.transform.rotate() a pygame.transform.rotozoom()

Obě funkce popsané v předchozích dvou kapitolách, tj. pygame.transform.rotate() i pygame.transform.rotozoom(), jsou použity v dnešním čtvrtém a současně i posledním demonstračním příkladu nazvaném pygame28. Kostra tohoto příkladu se podobá všem třem příkladům předchozím, takže se pouze zmiňme o tom, jak je navržena zobrazená scéna (viz též obrázek číslo 8). V horní řadě můžeme vidět původní bitmapu a za ní pak obrázky otočené o 90°, 180° a 270°. Podle očekávání v tomto případě nedošlo k žádnému zhoršení vizuálních kvalit bitmap, protože se pouze přeskupily jednotlivé pixely. V levém dolním rohu jsou zobrazeny dvě bitmapy otočené o -45° a o 45°, a to funkcí pygame.transform.rotate(), tj. bez změny měřítka. Naproti tomu v pravém dolním rohu jsou obrázky otočené o 30°, u nichž současně došlo ke změně měřítka:

#!/usr/bin/python
# vim: set fileencoding=utf-8

# Demonstrační příklady využívající knihovnu Pygame

# Příklad číslo 28: použití objektů typu Surface, metoda blit()
#                   a operace pygame.transform.rotate() + pygame.transform.rotozoom().


import pygame, sys, os

# Nutno importovat kvůli konstantám QUIT atd.
from pygame.locals import *

# Velikost okna aplikace
WIDTH = 400
HEIGHT = 400

# Inicializace knihovny Pygame 
pygame.init()

clock = pygame.time.Clock()

# Vytvoření okna pro vykreslování
display = pygame.display.set_mode([WIDTH, HEIGHT])

# Nastavení titulku okna
pygame.display.set_caption('Pygame test #28')

# Konstanty s n-ticemi představujícími základní barvy
BLACK   = (  0,   0,   0)

# Vyplnění plochy okna černou barvou
display.fill(BLACK)


# Načtení obrázku, který se bude vykreslovat a transformovat
image_surface = pygame.image.load(os.path.join('images', 'pygame.png'))

# Vytvoření otočených obrázků
rot90_image  = pygame.transform.rotate(image_surface, 90)
rot180_image = pygame.transform.rotate(image_surface, 180)
rot270_image = pygame.transform.rotate(image_surface, 270)
rot45_image  = pygame.transform.rotate(image_surface, 45)
rotm45_image  = pygame.transform.rotate(image_surface, -45)
rot_and_scaled_image_1 = pygame.transform.rotozoom(image_surface, 30, 0.7)
rot_and_scaled_image_2 = pygame.transform.rotozoom(image_surface, 30, 2.0)

# Přímé vykreslení původního obrázku
display.blit(image_surface, (20, 25))

# Přímé vykreslení otočených obrázků
display.blit(rot90_image,  (115, 25))
display.blit(rot180_image, (210, 25))
display.blit(rot270_image, (305, 25))
display.blit(rot45_image,  (20, 125))
display.blit(rotm45_image, (20, 245))
display.blit(rot_and_scaled_image_1, (220, 120))
display.blit(rot_and_scaled_image_2, (200, 200))



# Hlavní herní smyčka
while True:
    # Načtení a zpracování všech událostí z fronty
    for event in pygame.event.get():
        # Uzavřením okna běh aplikace ukončí
        if event.type == QUIT:
            pygame.quit()
            sys.exit()
        # Klávesou ESC se běh aplikace ukončí
        if event.type == KEYDOWN and event.key == K_ESCAPE:
            pygame.quit()
            sys.exit()

    pygame.display.update()
    clock.tick(20)

# finito

11. Obsah následující části seriálu

V navazující části tohoto seriálu dokončíme poměrně rozsáhlé téma věnované práci s bitmapami a sprity. Nejprve si popíšeme další funkce poskytované modulem pygame.transform a posléze si ukážeme, jak lze realizovat přesnou detekci kolizí spritů (či bitmap), přičemž kolize bude detekována s přesností na jeden pixel (to je více, než umožňují funkce popsané minule).

12. Repositář se zdrojovými kódy všech dnešních demonstračních příkladů

Všechny čtyři demonstrační příklady, s nimiž jsme se v dnešním článku seznámili, byly, podobně jako ve všech předchozích částech tohoto seriálu, uloženy do Git repositáře umístěného na GitHubu (https://github.com/tisnik/presentations). Poslední verze zdrojových kódů naleznete pod těmito odkazy:

# Příklad Zdrojový kód
1 pygame25.py https://github.com/tisnik/presentations/blob/master/pygame/pygame25.py
2 pygame26.py https://github.com/tisnik/presentations/blob/master/pygame/pygame26.py
3 pygame27.py https://github.com/tisnik/presentations/blob/master/pygame/pygame27.py
4 pygame28.py https://github.com/tisnik/presentations/blob/master/pygame/pygame28.py

13. Funkce použité v dnešních demonstračních příkladech

Opět si pro úplnost vypišme funkce a metody nabízené knihovnou Pygame, které jsme použili v dnešních čtyřech demonstračních příkladech:

  1. pygame.init()
    http://www.pygame.org/docs/ref/pygame.html#pygame.init
  2. pygame.quit()
    http://www.pygame.org/docs/ref/pygame.html#pygame.quit
  3. pygame.display.set_mode()
    http://www.pygame.org/docs/ref/display.html#pygame.display.set_mode
  4. pygame.display.set_caption()
    http://www.pygame.org/docs/ref/display.html#pygame.display.set_caption
  5. pygame.display.quit()
    http://www.pygame.org/docs/ref/display.html#pygame.display.quit
  6. pygame.display.update()
    http://www.pygame.org/docs/ref/display.html#pygame.display.update
  7. pygame.event.get()
    http://www.pygame.org/docs/ref/event.html#pygame.event.get
  8. pygame.time.Clock()
    http://www.pygame.org/docs/ref/time.html#pygame.time.Clock
  9. pygame.time.Clock.tick()
    http://www.pygame.org/docs/ref/time.html#pygame.time.Clock.tick
  10. pygame.Surface()
    http://www.pygame.org/docs/ref/surface.html
  11. pygame.Surface.fill()
    http://www.pygame.org/docs/ref/surface.html#pygame.Surface.fill
  12. pygame.image.load()
    http://www.pygame.org/docs/ref/image.html#pygame.image.load
  13. pygame.Surface.blit()
    http://www.pygame.org/docs/ref/surface.html#pygame.Surface.blit
  14. pygame.font.Font()
    http://www.pygame.org/docs/ref/font.html#pygame.font.Font
  15. pygame.font.Font.render()
    http://www.pygame.org/docs/ref/font.html#pygame.font.Font.render
  16. pygame.transform.flip()
    http://www.pygame.org/docs/ref/transform.html#pygame.transform.flip
  17. pygame.transform.scale()
    http://www.pygame.org/docs/ref/transform.html#pygame.transform.scale
  18. pygame.transform.smoothscale()
    http://www.pygame.org/docs/ref/transform.html#pygame.transform.smoothscale
  19. pygame.transform.rotate()
    http://www.pygame.org/docs/ref/transform.html#pygame.transform.rotate
  20. pygame.transform.rotozoom()
    http://www.pygame.org/docs/ref/transform.html#pygame.transform.rotozoom
  21. pygame.transform.get_smoothscale_backend()
    http://www.pygame.org/docs/ref/transform.html#pygame.transform.get_smoothscale_backend

14. Odkazy na Internetu

  1. Program Arcade Games With Python And Pygame
    http://programarcadegames.com/index.php?lang=en#
  2. Program Arcade Games With Python And Pygame: Chapter 13: Introduction to Sprites:
    http://programarcadegames.com/index.php?chapter=introduction_to_sprites#
  3. Pygame.org
    http://pygame.org/hifi.html
  4. Pygame – instalační soubory pro různé operační systémy
    http://pygame.org/download.shtml
  5. Pygame: documentation
    http://www.pygame.org/docs/
  6. Pygame Wiki: Getting Started
    http://www.pygame.org/wiki/GettingStarted
  7. Pygame Tutorials: Tutorials Basic
    http://pygametutorials.wikidot.com/tutorials-basic
  8. Pygame: Font class
    http://www.pygame.org/docs/ref/font.html
  9. Python.org (dokumentace k jazyku, odkazy na instalační soubory atd.)
    https://www.python.org/
  10. How to Draw with Pygame on Your Raspberry Pi
    http://www.dummies.com/how-to/content/how-to-draw-with-pygame-on-your-raspberry-pi.html
  11. Bresenham’s line algorithm
    https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm
  12. Xiaolin Wu’s line algorithm
    https://en.wikipedia.org/wiki/Xiaolin_Wu%27s_line_algorithm
  13. Pyglet
    https://pypi.python.org/pypi/pyglet/1.2.4
  14. Pyglet documentation
    http://pythonhosted.org/pyglet/
  15. PyOpenGL
    https://pypi.python.org/pypi/PyOpenGL/
  16. Computer font (Wikipedia)
    https://en.wikipedia.org/wiki/Computer_font
  17. TrueType (Wikipedia)
    https://en.wikipedia.org/wiki/TrueType
  18. SDL and Fonts
    http://www.gamedev.net/page/resources/_/technical/game-programming/sdl–fonts-r1953
  19. SDL_ttf Documentation
    http://www.libsdl.org/projects/SDL_ttf/docs/
  20. SDL_ttf 2.0 (není prozatím součástí SDLJava)
    http://www.libsdl.org/projects/SDL_ttf/
  21. SDL_ttf doc
    http://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_frame.html
  22. SDL 1.2 Documentation: SDL_Surface
    http://www.libsdl.org/release/SDL-1.2.15/docs/html/sdlsurface.html
  23. SDL 1.2 Documentation: SDL_PixelFormat
    http://www.libsdl.org/release/SDL-1.2.15/docs/html/sdlpixelformat.html
  24. SDL 1.2 Documentation: SDL_LockSurface
    http://www.libsdl.org/release/SDL-1.2.15/docs/html/sdllocksurface.html
  25. SDL 1.2 Documentation: SDL_UnlockSurface
    http://www.libsdl.org/release/SDL-1.2.15/docs/html/sdlunlocksurface.html
  26. SDL 1.2 Documentation: SDL_LoadBMP
    http://www.libsdl.org/release/SDL-1.2.15/docs/html/sdlloadbmp.html
  27. SDL 1.2 Documentation: SDL_SaveBMP
    http://www.libsdl.org/release/SDL-1.2.15/docs/html/sdlsavebmp.html
  28. SDL 1.2 Documentation: SDL_BlitSurface
    http://www.libsdl.org/release/SDL-1.2.15/docs/html/sdlblitsurface.html
  29. SDL 1.2 Documentation: SDL_VideoInfo
    http://www.libsdl.org/release/SDL-1.2.15/docs/html/sdlvideoinfo.html
  30. SDL 1.2 Documentation: SDL_GetVideoInfo
    http://www.libsdl.org/release/SDL-1.2.15/docs/html/sdlgetvideoinfo.html
  31. Graphical user interface (Wikipedia)
    http://en.wikipedia.org/wiki/Graphical_user_interface
  32. The Real History of the GUI
    http://articles.sitepoint.com/article/real-history-gui
  33. Computer-History: Xerox Alto
    http://www.mr-gadget.de/apple/2004-01-15/computer-history-xerox-alto
  34. bitsavers.org
    http://www.bitsavers.org/
  35. Dokumenty k počítači Xerox Alto na bitsavers.org
    http://www.bitsavers.org/pdf/xerox/alto/
  36. The ALTO Computer
    http://www.maniacworld.com/alto-computer-video.html
  37. Xerox Alto Operating System and Alto Applications
    http://www.digibarn.com/collections/software/alto/index.html
  38. Xerox Alto (Wikipedia)
    http://en.wikipedia.org/wiki/Xerox_Alto
  39. BitBLT routines (1975)
    http://www.bitsavers.org/pdf/xerox/alto/BitBLT_Nov1975.pdf
  40. BitBlt in Squeak
    http://wiki.squeak.org/squeak/189
  41. Bitmaps, Device Contexts and BitBlt
    http://www.winprog.org/tutorial/bitmaps.html
  42. BitBlt Game Programming Tutorial
    http://www.freevbcode.com/ShowCode.asp?ID=3677
  43. Bit blit (Wikipedia)
    http://en.wikipedia.org/wiki/BitBLT
  44. The Xerox Alto
    http://toastytech.com/guis/alto3.html
  45. History of the graphical user interface
    http://en.wikipedia.org/wiki/History_of_the_graphical_user_interface
  46. Domovská stránka systému LÖVE
    http://love2d.org/
  47. Dokumentace k systému LÖVE
    http://love2d.org/wiki/love
  48. Domovská stránka programovacího jazyka Lua
    http://www.lua.org/
  49. Seriál o programovacím jazyku Lua (root.cz):
    http://www.root.cz/serialy/programovaci-jazyk-lua/
  50. Web o Lieru, Gusanos, GeneRally, Atari atd.
    http://karelik.wz.cz/
  51. Web o Lieru, Gusanos
    http://karelik.wz.cz/gusanos.php
  52. GUSANOS
    http://gusanos.sourceforge.net/
  53. GUSANOS Download
    http://sourceforge.net/projects/gusanos/
  54. Lua
    http://www.linuxexpres.cz/praxe/lua
  55. Lua
    http://cs.wikipedia.org/wiki/Lua
  56. Lua (programming language)
    http://en.wikipedia.org/wiki/Lua_(programming_language)
  57. The Lua Programming Language
    http://www.tiobe.com/index.php/paperinfo/tpci/Lua.html
  58. Lua Programming Gems
    http://www.lua.org/gems/
  59. LuaForge
    http://luaforge.net/
  60. Forge project tree
    http://luaforge.net/softwaremap/trove_list.php
  61. SdlBasic home page
    http://www.sdlbasic.altervista.org/main/
  62. SdlBasic examples
    http://nitrofurano.linuxkafe.com/sdlbasic/
  63. SdlBasic na Wikipedii
    http://en.wikipedia.org/wiki/SdlBasic
  64. Simple DirectMedia Layer
    http://en.wikipedia.org/wiki/Simple_DirectMedia_Layer
  65. SDLBASIC – The high-level interpreter for all?
    http://openbytes.wordpress.com/2008/11/08/sdlbasic-the-high-level-interpreter-for-all/
  66. FreeBasic home page
    http://www.freebasic.net/
  67. FreeBASIC (Wikipedia EN)
    https://en.wikipedia.org/wiki/FreeBASIC
  68. FreeBASIC Wiki
    http://www.freebasic.net/wiki/wikka.php?wakka=FBWiki
  69. FreeBASIC Manual
    http://www.freebasic.net/wiki/wikka.php?wakka=DocToc
  70. FreeBASIC (Wikipedia CZ)
    http://cs.wikipedia.org/wiki/FreeBASIC
  71. The Griffon Legend
    http://syn9.thingie.net/?table=griffonlegend
  72. Seriál Letní škola programovacího jazyka Logo
    http://www.root.cz/serialy/letni-skola-programovaciho-jazyka-logo/
  73. Scratch: oficiální stránka projektu
    http://scratch.mit.edu/
  74. Scratch: galerie projektů vytvořených ve Scratchi
    http://scratch.mit.edu/galleries/browse/newest
  75. Scratch: nápověda
    file:///usr/share/scratch/Help/en/index.html
  76. Scratch: obrazovky nápovědy
    file:///usr/share/scratch/Help/en/allscreens.html
  77. Scratch (Wikipedie CZ)
    http://cs.wikipedia.org/wiki/Scratch
  78. Scratch (programming language)
    http://en.wikipedia.org/wiki/Scratch_(programming_language)
  79. Scratch Modification
    http://wiki.scratch.mit.edu/wiki/Scratch_Modification
  80. Scratch Lowers Resistance to Programming
    http://www.wired.com/gadgetlab/2009/03/scratch-lowers/
  81. Snap!
    http://snap.berkeley.edu/
  82. Prostředí Snap!
    http://snap.berkeley.edu/snapsource/snap.html
  83. Alternatives to Scratch
    http://wiki.scratch.mit.edu/wiki/Alternatives_to_Scratch
  84. Basic-256 home page
    http://www.basic256.org/index_en
  85. Basic-256 Language Documentation
    http://doc.basic256.org/doku.php
  86. Basic-256 Art Gallery
    http://www.basic256.org/artgallery
  87. Basic-256 Tutorial
    http://www.basic256.org/tutorials
  88. Why BASIC?
    http://www.basic256.org/whybasic
  89. A book to teach ANYBODY how to program a computer (using BASIC)
    http://www.basicbook.org/
  90. BASIC Computer Games (published 1978) – Hammurabi
    http://atariarchives.org/basicgames/showpage.php?page=78
  91. Hamurabi – zdrojový kód v BASICu
    http://www.dunnington.u-net.com/public/basicgames/HMRABI