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
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
9. Rotace obrázku současně se změnou měřítka
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
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.
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.
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.
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).
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é:
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.
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().
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:
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:
- pygame.init()
http://www.pygame.org/docs/ref/pygame.html#pygame.init - pygame.quit()
http://www.pygame.org/docs/ref/pygame.html#pygame.quit - pygame.display.set_mode()
http://www.pygame.org/docs/ref/display.html#pygame.display.set_mode - pygame.display.set_caption()
http://www.pygame.org/docs/ref/display.html#pygame.display.set_caption - pygame.display.quit()
http://www.pygame.org/docs/ref/display.html#pygame.display.quit - pygame.display.update()
http://www.pygame.org/docs/ref/display.html#pygame.display.update - pygame.event.get()
http://www.pygame.org/docs/ref/event.html#pygame.event.get - pygame.time.Clock()
http://www.pygame.org/docs/ref/time.html#pygame.time.Clock - pygame.time.Clock.tick()
http://www.pygame.org/docs/ref/time.html#pygame.time.Clock.tick - pygame.Surface()
http://www.pygame.org/docs/ref/surface.html - pygame.Surface.fill()
http://www.pygame.org/docs/ref/surface.html#pygame.Surface.fill - pygame.image.load()
http://www.pygame.org/docs/ref/image.html#pygame.image.load - pygame.Surface.blit()
http://www.pygame.org/docs/ref/surface.html#pygame.Surface.blit - pygame.font.Font()
http://www.pygame.org/docs/ref/font.html#pygame.font.Font - pygame.font.Font.render()
http://www.pygame.org/docs/ref/font.html#pygame.font.Font.render - pygame.transform.flip()
http://www.pygame.org/docs/ref/transform.html#pygame.transform.flip - pygame.transform.scale()
http://www.pygame.org/docs/ref/transform.html#pygame.transform.scale - pygame.transform.smoothscale()
http://www.pygame.org/docs/ref/transform.html#pygame.transform.smoothscale - pygame.transform.rotate()
http://www.pygame.org/docs/ref/transform.html#pygame.transform.rotate - pygame.transform.rotozoom()
http://www.pygame.org/docs/ref/transform.html#pygame.transform.rotozoom - pygame.transform.get_smoothscale_backend()
http://www.pygame.org/docs/ref/transform.html#pygame.transform.get_smoothscale_backend
14. Odkazy na Internetu
- Program Arcade Games With Python And Pygame
http://programarcadegames.com/index.php?lang=en# - Program Arcade Games With Python And Pygame: Chapter 13: Introduction to Sprites:
http://programarcadegames.com/index.php?chapter=introduction_to_sprites# - Pygame.org
http://pygame.org/hifi.html - Pygame - instalační soubory pro různé operační systémy
http://pygame.org/download.shtml - Pygame: documentation
http://www.pygame.org/docs/ - Pygame Wiki: Getting Started
http://www.pygame.org/wiki/GettingStarted - Pygame Tutorials: Tutorials Basic
http://pygametutorials.wikidot.com/tutorials-basic - Pygame: Font class
http://www.pygame.org/docs/ref/font.html - Python.org (dokumentace k jazyku, odkazy na instalační soubory atd.)
https://www.python.org/ - 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 - Bresenham's line algorithm
https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm - Xiaolin Wu's line algorithm
https://en.wikipedia.org/wiki/Xiaolin_Wu%27s_line_algorithm - Pyglet
https://pypi.python.org/pypi/pyglet/1.2.4 - Pyglet documentation
http://pythonhosted.org/pyglet/ - PyOpenGL
https://pypi.python.org/pypi/PyOpenGL/ - Computer font (Wikipedia)
https://en.wikipedia.org/wiki/Computer_font - TrueType (Wikipedia)
https://en.wikipedia.org/wiki/TrueType - SDL and Fonts
http://www.gamedev.net/page/resources/_/technical/game-programming/sdl--fonts-r1953 - SDL_ttf Documentation
http://www.libsdl.org/projects/SDL_ttf/docs/ - SDL_ttf 2.0 (není prozatím součástí SDLJava)
http://www.libsdl.org/projects/SDL_ttf/ - SDL_ttf doc
http://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_frame.html - SDL 1.2 Documentation: SDL_Surface
http://www.libsdl.org/release/SDL-1.2.15/docs/html/sdlsurface.html - SDL 1.2 Documentation: SDL_PixelFormat
http://www.libsdl.org/release/SDL-1.2.15/docs/html/sdlpixelformat.html - SDL 1.2 Documentation: SDL_LockSurface
http://www.libsdl.org/release/SDL-1.2.15/docs/html/sdllocksurface.html - SDL 1.2 Documentation: SDL_UnlockSurface
http://www.libsdl.org/release/SDL-1.2.15/docs/html/sdlunlocksurface.html - SDL 1.2 Documentation: SDL_LoadBMP
http://www.libsdl.org/release/SDL-1.2.15/docs/html/sdlloadbmp.html - SDL 1.2 Documentation: SDL_SaveBMP
http://www.libsdl.org/release/SDL-1.2.15/docs/html/sdlsavebmp.html - SDL 1.2 Documentation: SDL_BlitSurface
http://www.libsdl.org/release/SDL-1.2.15/docs/html/sdlblitsurface.html - SDL 1.2 Documentation: SDL_VideoInfo
http://www.libsdl.org/release/SDL-1.2.15/docs/html/sdlvideoinfo.html - SDL 1.2 Documentation: SDL_GetVideoInfo
http://www.libsdl.org/release/SDL-1.2.15/docs/html/sdlgetvideoinfo.html - Graphical user interface (Wikipedia)
http://en.wikipedia.org/wiki/Graphical_user_interface - The Real History of the GUI
http://articles.sitepoint.com/article/real-history-gui - Computer-History: Xerox Alto
http://www.mr-gadget.de/apple/2004-01-15/computer-history-xerox-alto - bitsavers.org
http://www.bitsavers.org/ - Dokumenty k počítači Xerox Alto na bitsavers.org
http://www.bitsavers.org/pdf/xerox/alto/ - The ALTO Computer
http://www.maniacworld.com/alto-computer-video.html - Xerox Alto Operating System and Alto Applications
http://www.digibarn.com/collections/software/alto/index.html - Xerox Alto (Wikipedia)
http://en.wikipedia.org/wiki/Xerox_Alto - BitBLT routines (1975)
http://www.bitsavers.org/pdf/xerox/alto/BitBLT_Nov1975.pdf - BitBlt in Squeak
http://wiki.squeak.org/squeak/189 - Bitmaps, Device Contexts and BitBlt
http://www.winprog.org/tutorial/bitmaps.html - BitBlt Game Programming Tutorial
http://www.freevbcode.com/ShowCode.asp?ID=3677 - Bit blit (Wikipedia)
http://en.wikipedia.org/wiki/BitBLT - The Xerox Alto
http://toastytech.com/guis/alto3.html - History of the graphical user interface
http://en.wikipedia.org/wiki/History_of_the_graphical_user_interface - Domovská stránka systému LÖVE
http://love2d.org/ - Dokumentace k systému LÖVE
http://love2d.org/wiki/love - Domovská stránka programovacího jazyka Lua
http://www.lua.org/ - Seriál o programovacím jazyku Lua (root.cz):
http://www.root.cz/serialy/programovaci-jazyk-lua/ - Web o Lieru, Gusanos, GeneRally, Atari atd.
http://karelik.wz.cz/ - Web o Lieru, Gusanos
http://karelik.wz.cz/gusanos.php - GUSANOS
http://gusanos.sourceforge.net/ - GUSANOS Download
http://sourceforge.net/projects/gusanos/ - Lua
http://www.linuxexpres.cz/praxe/lua - Lua
http://cs.wikipedia.org/wiki/Lua - Lua (programming language)
http://en.wikipedia.org/wiki/Lua_(programming_language) - The Lua Programming Language
http://www.tiobe.com/index.php/paperinfo/tpci/Lua.html - Lua Programming Gems
http://www.lua.org/gems/ - LuaForge
http://luaforge.net/ - Forge project tree
http://luaforge.net/softwaremap/trove_list.php - SdlBasic home page
http://www.sdlbasic.altervista.org/main/ - SdlBasic examples
http://nitrofurano.linuxkafe.com/sdlbasic/ - SdlBasic na Wikipedii
http://en.wikipedia.org/wiki/SdlBasic - Simple DirectMedia Layer
http://en.wikipedia.org/wiki/Simple_DirectMedia_Layer - SDLBASIC – The high-level interpreter for all?
http://openbytes.wordpress.com/2008/11/08/sdlbasic-the-high-level-interpreter-for-all/ - FreeBasic home page
http://www.freebasic.net/ - FreeBASIC (Wikipedia EN)
https://en.wikipedia.org/wiki/FreeBASIC - FreeBASIC Wiki
http://www.freebasic.net/wiki/wikka.php?wakka=FBWiki - FreeBASIC Manual
http://www.freebasic.net/wiki/wikka.php?wakka=DocToc - FreeBASIC (Wikipedia CZ)
http://cs.wikipedia.org/wiki/FreeBASIC - The Griffon Legend
http://syn9.thingie.net/?table=griffonlegend - Seriál Letní škola programovacího jazyka Logo
http://www.root.cz/serialy/letni-skola-programovaciho-jazyka-logo/ - Scratch: oficiální stránka projektu
http://scratch.mit.edu/ - Scratch: galerie projektů vytvořených ve Scratchi
http://scratch.mit.edu/galleries/browse/newest - Scratch: nápověda
file:///usr/share/scratch/Help/en/index.html - Scratch: obrazovky nápovědy
file:///usr/share/scratch/Help/en/allscreens.html - Scratch (Wikipedie CZ)
http://cs.wikipedia.org/wiki/Scratch - Scratch (programming language)
http://en.wikipedia.org/wiki/Scratch_(programming_language) - Scratch Modification
http://wiki.scratch.mit.edu/wiki/Scratch_Modification - Scratch Lowers Resistance to Programming
http://www.wired.com/gadgetlab/2009/03/scratch-lowers/ - Snap!
http://snap.berkeley.edu/ - Prostředí Snap!
http://snap.berkeley.edu/snapsource/snap.html - Alternatives to Scratch
http://wiki.scratch.mit.edu/wiki/Alternatives_to_Scratch - Basic-256 home page
http://www.basic256.org/index_en - Basic-256 Language Documentation
http://doc.basic256.org/doku.php - Basic-256 Art Gallery
http://www.basic256.org/artgallery - Basic-256 Tutorial
http://www.basic256.org/tutorials - Why BASIC?
http://www.basic256.org/whybasic - A book to teach ANYBODY how to program a computer (using BASIC)
http://www.basicbook.org/ - BASIC Computer Games (published 1978) - Hammurabi
http://atariarchives.org/basicgames/showpage.php?page=78 - Hamurabi - zdrojový kód v BASICu
http://www.dunnington.u-net.com/public/basicgames/HMRABI
