-
1
-
Obsah
1 Úvod.................................................................................................................................... 5
1.1
Doporučení........................................................................................................................................... 5
1.2
Důležité pojmy..................................................................................................................................... 5
2 Moderní grafické adaptéry ............................................................................................ 12
2.1
Motivace vývoje................................................................................................................................. 12
2.2
Historie a vývoj.................................................................................................................................. 13
2.2.1
Grafické akcelerátory 1. generace ................................................................................................. 13
2.2.2
Grafické akcelerátory 2. generace ................................................................................................. 13
2.2.3
Grafické akcelerátory 3. generace ................................................................................................. 14
2.2.4
Grafické akcelerátory 4. generace ................................................................................................. 14
2.2.5
Špičkové grafické akcelerátory ..................................................................................................... 14
2.3
Architektura grafických adaptérů....................................................................................................... 14
2.3.1
Bloková struktura .......................................................................................................................... 14
2.3.2
Rozhraní AGP grafických akcelerátorů......................................................................................... 16
2.4
Vlastnosti, možnosti........................................................................................................................... 17
2.4.1
Nejdůležitější charakteristiky grafických adaptérů ....................................................................... 17
2.4.2
Standardní podporované funkce.................................................................................................... 18
2.4.3
Další podporované funkce............................................................................................................. 19
3 Grafická rozhraní ........................................................................................................... 24
3.1
Úvod................................................................................................................................................... 24
3.2
Grafická rozhraní v jednotlivých systémech...................................................................................... 24
3.2.1
Systémy IBM-PC kompatibilní - MS-DOS................................................................................... 24
3.2.2
Systémy Microsoft Windows ........................................................................................................ 25
3.2.3
Systémy Linux .............................................................................................................................. 27
3.3
Rozhraní OpenGL.............................................................................................................................. 28
3.3.1
Platformy podporující OpenGL..................................................................................................... 30
3.3.2
Současný stav rozhraní OpenGL na PC ........................................................................................ 30
3.3.3
Stávající knihovny a nadstavby pro OpenGL................................................................................ 31
4 Návrh grafické knihovny MGL ..................................................................................... 32
4.1
Zadání diplomové práce..................................................................................................................... 32
-
2
-
4.2
Současný stav 2D grafických rozhraní............................................................................................... 32
4.3
Účel mnou navržené knihovny a motivace vývoje ............................................................................ 32
4.4
Typický uživatel knihovny MGL....................................................................................................... 33
4.5
Možnosti knihovny MGL................................................................................................................... 34
4.6
Požadavky knihovny MGL ................................................................................................................ 37
5 Implementace knihovny ................................................................................................. 38
5.1
Struktura knihovny............................................................................................................................ 38
5.2
Postup implementace knihovny s diskusí možných řešení................................................................. 39
5.2.1
Práce s okny .................................................................................................................................. 39
5.2.2
Základní parametry obrazového režimu........................................................................................ 39
5.2.3
Vstupy myši a klávesnice.............................................................................................................. 39
5.2.4
Časovač ......................................................................................................................................... 40
5.2.5
Konstrukce základních grafických primitiv .................................................................................. 40
5.2.6
Realizace obrazových map............................................................................................................ 40
5.2.7
Realizace fontů.............................................................................................................................. 41
5.2.8
Ošetření chyb ................................................................................................................................ 43
5.2.9
Práci s vrstvami, řešícími problém překrývání grafických objektů ............................................... 43
5.2.10
Spolupráce s ostatními příkazy OpenGL.................................................................................. 43
6 Instalace knihovny MGL................................................................................................ 44
6.1
Obecná platforma............................................................................................................................... 44
6.2
Platforma Windows ........................................................................................................................... 44
6.3
Platforma Linux ................................................................................................................................. 45
7 Srovnání knihovny MGL s prostředky OpenGL ......................................................... 46
7.1
Srovnávací příklad alpha.................................................................................................................... 46
7.2
Srovnávací příklad checker................................................................................................................ 47
7.3
Srovnávací příklad tunnel .................................................................................................................. 47
8 Testování navržené knihovny ........................................................................................ 50
8.1
Metodika testování............................................................................................................................. 50
8.2
Lidé, kteří prováděli testování............................................................................................................ 52
8.3
Seznam vybavení a platforem, na kterých byly provedeny testy ....................................................... 53
8.4
Výsledky testování............................................................................................................................. 54
9 Stav implementace .......................................................................................................... 55
10 Závěr ................................................................................................................................ 56
-
3
-
11 Použitá literatura a zdroje ............................................................................................. 58
11.1
Literatura............................................................................................................................................ 58
11.2
Elektronické dokumenty .................................................................................................................... 58
11.2.1
Nápovědy a dokumentace programových nástrojů................................................................... 58
11.2.2
Články a dokumenty ze sítě Internet ........................................................................................ 59
12 Doporučené Internetové stránky ................................................................................... 63
12.1.1
OpenGL.................................................................................................................................... 63
12.1.2
Kurzy a ukázkové příklady OpenGL (tutorials) ....................................................................... 63
12.1.3
Výrobci grafických akcelerátorů .............................................................................................. 64
12.1.4
Stránky zabývající se recenzemi grafických adaptérů a ostatního hardwaru............................ 64
12.1.5
Ostatní stránky.......................................................................................................................... 65
13 Příloha .............................................................................................................................. 66
13.1
Obsah přiložených disket ................................................................................................................... 66
13.2
Popis funkcí knihovny MGL.............................................................................................................. 67
13.2.1
Modul Window......................................................................................................................... 67
13.2.2
Modul Mgl................................................................................................................................ 70
13.2.3
Modul Draw ............................................................................................................................. 72
13.2.4
Modul Images........................................................................................................................... 77
13.2.5
Modul Textures ........................................................................................................................ 81
13.2.6
Modul Fonts ............................................................................................................................. 84
13.2.7
Modul Input.............................................................................................................................. 88
13.2.8
Modul Errors ............................................................................................................................ 93
13.2.9
Modul Memory......................................................................................................................... 97
13.3
Výpisy vybraných zdrojových souborů a částí kódu.......................................................................... 97
13.3.1
Výpis souboru alpha.c .............................................................................................................. 97
13.3.2
Výpis souboru alpha_m.c ....................................................................................................... 100
13.3.3
Výpis programu checker.c...................................................................................................... 101
13.3.4
Výpis programu checkr_m.c................................................................................................... 104
13.3.5
Fragmenty kódů srovnávacího příkladu tunnel ...................................................................... 106
-
4
-
Programová rozhraní pro grafické adaptéry
Úvod
-
5
-
1
Úvod
1.1
Doporučení
Tato práce se zabývá problematikou a moderních grafických adaptérů a grafických rozhraní, zejména
rozhraní OpenGL. Vzhledem k rozsahu této práce není samozřejmě možné tuto problematiku pokrýt v plné šíři a
hloubce. Pro zájemce o hlubší seznámení s touto problematikou autor doporučuje uvedené elektronické doku-
menty v podkapitole Použitá literatura a zdroje, případně odkazy v kapitole Doporučené stránky. Nejdůležitější
pojmy, použité v dalším textu diplomové práce, jsou vysvětleny v následující podkapitole.
1.2
Důležité pojmy
•
Barva RGB (RGB color)
Barva, která je určena pomocí intenzit tří složek červené (red), zelené (green) a modré (blue).
•
Bilineární interpolace (někdy filtrace textur)
Technika, která umožňuje zlepšit vzhled textur při změnách velikosti. Mírným rozostřením eliminuje známou
„čtverečkovanost“ objektů potažených texturami a nežádoucí efekty, které vzniknou bez použití této techniky.
Tyto efekty jsou nejvíce patrné při pohybu objektů, na nichž jsou tyto textury naneseny.
Obrázek 1 –Textura šachovnice nanesená bez bilineárního filtrování (vlevo)
Obrázek 2 – Textura šachovnice nanesená s bilineárním filtrováním (vpravo)
Programová rozhraní pro grafické adaptéry
Úvod
-
6
-
•
Barevná redukce (dithering)
Technika, která umožňuje konverzi více barev na méně při zachování stejné kvality.Tak je možné použít textury
ve 32-bitové barevné hloubce při zobrazení na 16-bitovém displeji nebo 256 barevném.
•
Dvojitá obrazová paměť (double buffer)
Technologie, která zajišťuje, že nová vykreslovaná grafická data nejsou kreslena do stejného rámce, jehož obsah
je zobrazován na obrazovce. Po vykreslení obrazu se původní rámec s novým rámcem vymění. Takto není obraz
kreslen do rámce viditelného na obrazovce, a jsou tak odstraněny nežádoucí efekty (problikávání obrazu), které
by byly bez použití této technologie viditelné.
•
Geometrická primitiva
Umožňují kreslení matematicky popsaných objektů. Mezi primitiva patří body, čáry a polygony.
•
GLU
Knihovna OpenGL Utility Library (GLU) obsahuje některé pomocné funkce pro práci s OpenGL. Je standardní
součástí rozhraní OpenGL a obsahuje jej každá implementace OpenGL.
•
GLUT
OpenGL Utility Toolkit (GLUT) je přenositelná knihovna, rozšiřující možnosti OpenGL o podporu práce s okny,
vstupními zařízeními apod. Jde o funkce, které OpenGL díky své obecnosti nenabízí. GLUT je k dispozici zdar-
ma pro velké množství platforem. GLUT (stejně jako OpenGL) mohou aplikační programátoři používat zdarma.
•
Grafická knihovna (graphical API)
Programové knihovny, které nabízejí snadnou práci s grafickým rozhraním. Tyto knihovny umožňují programá-
torovi přístup k možnostem grafického podsystému. Příkladem je knihovna OpenGL.
•
Grafické rozhraní
Programová vrstva zajišťující spolupráci a přístup k možnostem grafického podsystému se softwarem operační-
ho systému a aplikací.
•
Hardwarová akcelerace grafických adaptérů
Technika umožňující rychlejší provádění grafických operací využitím možností grafického adaptéru. Bez těchto
možností je nutné grafické operace provést systémovým procesorem.
•
Interpolace barev (color interpolation)
Metoda obarvení čar nebo ploch vypočtením průměrných hodnot vzhledem ke vzdálenostem od vrcholů objektu,
kterým jsou barvy přiřazeny. Laicky a jednoduše řečeno jde o míchání barev, tak aby bylo dosaženo plynulých
přechodů.
Programová rozhraní pro grafické adaptéry
Úvod
-
7
-
Obrázek 3 - Barevná interpolace na trojúhelníku
•
Nadstavba programové knihovny (API shell)
Nová programová knihovna, rozšiřující možnosti původní programové knihovny. Knihovna přidává vlastní kód
pro zjednodušení nebo doplnění určitého výběru možností a funkcí. Vychází z možností původní knihovny.
•
Mapování textur (texture mapping)
Technologie pokrývání povrchů ploch a těles barevnými obrazovými mapami. Tato technika velmi napomáhá
zvýšit realističnost modelovaného objektu. Jedná se o jednu z nejzákladnějších a nejpoužívanějších funkci ve
většině dnešních 3D aplikací.
Obrázek 4 – Demonstrace nanesení textury na přední stranu krychle
Čtenáře s hlubším zájmem o tuto problematiku odkazuji literaturu [3] a článek [46].
Programová rozhraní pro grafické adaptéry
Úvod
-
8
-
•
Mapování textur s perspektivní korekcí
Při použití této techniky se při nanášení textury počítá s tím, že vzdálenější část textury bude menší, než část
bližší. To umožňuje zabránit deformaci způsobenou různou vzdáleností části objektu od pozorovatele.
•
Mipmapy (mipmapping)
Technika, pomocí které je umožněno rozhraní OpenGL rychleji a v dobré obrazové kvalitě provádět změnu
velikosti zobrazovaných textur. Před použitím textur se pomocí určitých algoritmů pro změnu velikosti vygene-
ruje pro danou texturu několik mipmap v různých velikostech. Při mapování textury na polygony se potom pou-
žije taková mipmapa, která svou velikostí nejlépe odpovídá potřebné velikosti. Ke každé textuře je generováno
několik mipmap. V praxi se tvoří mipmapy vždy poloviční velikosti původní textury. Takto zabírají textury
přibližně čtvrtinu paměti navíc, narozdíl od situace kdy použity nejsou. Takto je možné mapování textur prová-
dět rychleji a v lepší kvalitě. Kvalitu obrazu lze zlepšit použitím technik bilineární a trilineární interpolace. Zlep-
šení se projeví zejména na přechodech jednotlivých mipmap a na úsecích, kde jsou naneseny již značně zmen-
šené textury.
Obrázek 5 –Deska šachovnice vykreslená pomocí textur a s pomocí technologie mipmap. Pro vzdálenější úseky
jsou postupně používány mipmapy dalších úrovní (vlevo)
Obrázek 6 – Zde je ukázáno, které mipmapy jsou v použity v konkrétním úseku šachovnice (vpravo)
•
Míchání průhledných vrstev (alpha blending)
Technika pro vytváření průhledných objektů. Je založena na kombinaci barev vykreslovaných bodů s těmi, které
jsou již nakresleny v obrazovém rámci. V počítačové grafice lze této techniky použít například pro světla
a efekty pro uživatelské rozhraní.
Programová rozhraní pro grafické adaptéry
Úvod
-
9
-
Obrázek 7 – Trojúhelník a čtverec nakreslené přes sebe se zapnutým mícháním průhledných vrstev
•
Obrazová mapa (sprite)
Obdélníkový výřez, v němž jsou určeny barvy jednotlivých bodů. Příkladem je ikona nebo obrázek.
•
Obrazový rámec (framebuffer)
Jedná se o aktuálně zobrazovanou část obrazové paměti grafického adaptéru. Po vytvoření obrazu je obsah této
paměti přímo zobrazen na zobrazovacím zařízení.
•
OpenGL
Legendární grafická knihovna vytvořená firmou SGI pro práci s 2D a 3D grafikou. Jedná se o jedinečný nástroj
pro tvorbu přenositelných 2D a 3D grafických aplikací.
•
Paměť hloubky (Z buffer)
Nejčastěji používaná technika pro zobrazování 3D objektů do dvourozměrného pole lokální paměti grafického
adaptéru při práci s prostorovou grafikou. Paměť hloubky je rezervovaná část grafické paměti, která udržuje pro
každý obrazový bod jeho informaci o jeho souřadnici Z. Při kreslení polygonu, je každá hloubka nového bodu
porovnávaná s odpovídající hodnotou v paměti hloubky. Pokud je hodnota v paměti hloubky menší než hloubka
nového bodu, pak bod je viditelný a bude zobrazen. Hodnota v paměti hloubky je pak aktualizována hloubkou
nového bodu. V opačném případě to znamená, že jej bod nějakého nakresleného objektu překrývá a nový bod
zobrazen není. Pro každý bod obrazu se zaznamenává jeho prostorová hloubka. Výhodou je, že se nemusí propo-
čítávat objekty, které nejsou vidět (jsou zastíněny objekty před nimi), nevýhodou je nutnost použití další paměti
pro uchování informace o hloubce bodu. Pro zaznamenání hloubky jednotlivého bodu se používá obvykle 16
nebo 32 bitů.
•
Programové knihovny (Application Program Interface - API)
Knihovny funkcí, které umožňují programátorům používat určité algoritmy a metody bez nutnosti psát vlastní
kód řešící daný problém.
Programová rozhraní pro grafické adaptéry
Úvod
-
10
-
•
Průhlednost (alpha)
Rozšiřuje hodnoty barev o údaj vypovídající o průhlednosti použité barvy. Barva RGB rozšířená o tuto složku se
označuje jako RGBA
•
Rasterizace (rasterization)
Část zobrazovacího řetězce, která má za úkol vykreslovat objekty s vypočtenými atributy do obrazového rámce.
•
Stínování (shading)
Metody pro vybarvování ploch geometrických objektů, pro definované zdroje světla. Nejběžnější metody jsou:
•
Konstantní stínovaní – je charakteristické tím, že celá plocha má jen jednu barvu,
•
Gouradovo – je charakteristické tím, že barvy bodů uvnitř plochy jsou vypočítány interpolací hran po-
lygonu,
•
Phongovo stínování – je charakteristické tím, že pro každý bod je prováděn samostatný výpočet barvy
vlivem osvětlení.
Obrázek 8 - Konstantní stínování (vlevo), Obrázek 9 - Gouradovo stínování (vpravo)
Čtenáře s hlubším zájmem o tuto problematiku odkazuji na literaturu [3] a [4].
•
Trilineární interpolace
Tato technika umožňuje odstranit nežádoucí efekty, které vznikají při nanášení textur na objekt při použití tech-
nologie mipmap. Mohou vznikat mezi dvěma místy, kde jsou použity dvě různé mipmapy. Trilineární interpola-
ce tyto efekty odstraňuje rozmazáním sousedních mipmap. Kvalita obrazu se tak mírně zlepší.
Čtenáře s hlubším zájmem o tuto problematiku odkazuji na článek [54].
•
Vyhlazování hran (antialiasing)
Techniky pro odstranění schodovitosti vykreslených objektů (např. čar), které vznikají důsledkem toho, že obraz
(na monitoru nebo jiném zařízení) je vytvořen z bodů určité velikosti. Schodovitost je nejvíce patrná na zobrazo-
vacích zařízeních s nízkou rozlišovací schopností.
Programová rozhraní pro grafické adaptéry
Úvod
-
11
-
Obrázek 10 -Příklad nevyhlazené a vyhlazené úsečky (vlevo), Obrázek 11 -Zvětšený detail obou úseček (vpravo)
Programová rozhraní pro grafické adaptéry
Moderní grafické
-
12
-
2
Moderní grafické adaptéry
2.1
Motivace vývoje
Ještě před zhruba čtyřmi lety bylo jediným způsobem ke zrychlení výkonu počítače v aplikacích pracují-
cích s 3D grafikou na PC postupné zvyšování výkonu procesoru. Tehdejší grafické adaptéry podporovaly maxi-
málně akceleraci 2D operací. Výkon tehdejších procesorů, založených na architektuře Intel ale, ani zdaleka ne-
dostačoval k uspokojivému provozu různých 3D aplikací. To se týkalo především her, které zobrazovaly 3D
prostředí v reálném čase a podporovaly práci s grafikou ve vysokých rozlišeních a s velkým počtem barev.
Prakticky veškeré výpočty prováděl samotný systémový procesor. Takovýto postup ovšem velmi zatěžo-
val nejen jej, ale i systémovou sběrnici a paměť. Jako příklad si vezměme provoz aplikace běžící v reálném čase
(například hry) v rozlišení 1024 x 768 v 16-bitové barevné hloubce. Vypočteme objemy dat, které je třeba pře-
nést po systémové sběrnici pro plynulý pohyb v jejím prostředí (tj. alespoň 30 snímků za sekundu). Jeden sní-
mek představuje přenos 1536 kB po sběrnici do grafického adaptéru. Za jednu sekundu to již je 46MB. Vzhle-
dem k tomu, že procesor musí pro každý bod 3D objektu spočítat jeho umístění na obrazovce, jeho barvu, prová-
dět interpolaci mezi body, propočítávat textury apod., je pro vytvoření obrazu je nucen systémový procesor pra-
covat s daty řádově stovek MB za sekundu. Na úkor vizuální kvality obrazu je navíc nutné používat různé zjed-
nodušené výpočty scény.
Proto se přistoupilo k výrobě speciálních grafických adaptérů – grafických akcelerátorů, umožňujících
provádět určité grafické operace, zejména mapování textur bez zátěže procesoru. Vzhledem ke specializaci těch-
to zařízení bylo možné snadno dosáhnout větší rychlosti a vyšší kvality zobrazení, než při výpočtech v proceso-
ru. Grafická data jsou uložena v lokální paměti grafického akcelerátoru. Procesor posílá přes sběrnici pouze
příkazy, kterými grafickému akcelerátoru sděluje, jaké operace má provést. Ty obvykle nejsou založeny na vy-
kreslování bodů, ale celých grafických primitiv. Zbytek výpočtu je již proveden nezávisle na systémovém proce-
soru.
Nutno přiznat, že bouřlivý vývoj, které grafické akcelerátory na PC v posledních čtyřech letech prodělaly,
byl dán především velkou poptávkou trhu po počítačových hrách. Hry na této platformě nadále představují bez-
konkurenčně nejčastěji používané aplikace, schopné využívat možností těchto grafických adaptérů nové genera-
ce. Právě náročnost nejnovějších z nich je jedním z hlavních důvodů nutnosti pokračovat nadále ve vývoji i
v tyto dny. Postupně vznikají další a další technologie, které byly ještě nedávno k vidění jen na drahých pracov-
ních stanicích. Kvalita obrazu 3D scén se postupně krok za krokem (jedním z posledních je právě hloubkové
mapování, které je popsané dále) blíží k fotorealistické kvalitě.
Programová rozhraní pro grafické adaptéry
Moderní grafické
-
13
-
2.2
Historie a vývoj
Jedny z úplně prvních grafických akcelerátorů, které dokázaly, že akcelerace 3D grafiky na platformě PC
má smysl, byly akcelerátory od firmy S3, vybavené čipy Virge a známý Mystique od kanadské firmy Matrox.
Přestože tyto akcelerátory nenabízely ani zdaleka takový výkon jako dnešní grafické akcelerátory, přesto se
vytvářely aplikace, které využívaly jejich možností. Tyto akcelerátory doplatily na rychlý vývoj v grafických
technologiích, protože nepodporovaly spoustu řadu dnes už standardních funkcí. Grafické akcelerátory lze podle
rámcového výkonu a velikosti grafické paměti zhruba dělit do 3 generací. Příchod každé generace přibližně
znamenal zdvojnásobení grafické paměti a výkonu.
2.2.1
Grafické akcelerátory 1. generace
Naprostý převrat v oblasti 3D akcelerace nastal poté, co se zhruba před třemi lety (začátek roku 1997) na
trhu objevily grafické akcelerátory osazené čipy Voodoo Graphics od firmy 3Dfx (Diamond Monster 3D, Orchid
Righteous 3D a Canoponus Pure3D). Tyto čipy nabízely ve své době neuvěřitelně rychlou akceleraci grafiky v
16-bitové grafice s vysokou kvalitou obrazu v rozlišení 640 na 480 bodů. Zajímavostí bylo, že akcelerátory osa-
zené čipy Voodoo Graphics byly přídavným 3D akcelerátorem. Ke svému provozu potřebovaly ještě „obyčejný“
grafický adaptér, zajišťující 2D operace. S tímto grafickým adaptérem byly akcelerátory 3Dfx spojeny kablíkem
do rozšiřujícího konektoru (feature connector). Tyto akcelerátory tedy potřebovaly další PCI slot. Později se
vyráběly akcelerátory s čipy Voodoo Rush, které se daly použít samostatně. Navíc umožňovaly provoz 3D apli-
kací i v okně, což akcelerátory s čipy Voodoo Graphics neumožňovaly.
Akcelerátory založené na těchto čipech dosáhly masového rozšíření a způsobily bouřlivý vývoj těchto zařízení.
Akcelerátory 3Dfx Voodoo znamenaly určitý standard kvality a výkonu, podle kterého další firmy vyráběly
konkurenční čipy (např. nVidia Riva 128, 3Dfx Voodoo Rush, NEC/VL Power VR PCX2, Number Nine Ticket
To Ride 2, Rendition Verite 2x00, ATI Rage Pro a 3DLabs Permedia 2 a Permedia 3). Rodina těchto grafických
akcelerátorů se označuje jako 1. generace 3D akcelerátorů. Obvykle se dodávali se 4 MB – 8 MB grafické pamě-
ti. Tato generace obvykle podporovala rozhraní DirectX, případně vlastní API. Plná podpora OpenGL nebyla
k dispozici (tyto ovladače k některým z nich byly k dispozici až po zhruba dvou letech od uvedení). Místo toho
všechny podporovaly ovladače MiniGL, což je OpenGL omezené jen na některé funkce, potřebné pro provoz
počítačových her založených na tomto standardu.
2.2.2
Grafické akcelerátory 2. generace
Tyto akcelerátory výkonem o třídu překonávají čipy 1.generace. Používaly se zhruba před dvěmi lety. Mezi
těmito čipy, výkonem, kvalitou a cenou přesvědčivá řešení byly 3Dfx Voodoo II (opět se jednalo o přídavný
akcelerátor jako u čipu Voodoo Graphics), 3Dfx Voodoo Banshee, Matrox G200, Intel i740, S3 Savage3D,
nVidia Riva TNT. Akcelerátory osazené těmito čipy používaly 8 až 16 MB grafické paměti. Přestože se ještě
ojediněle vyrábějí grafické akcelerátory používající některé z těchto čipů, jejich použití lze doporučit pouze pro
systémy s pomalejšími procesory (Pentium I, AMD K6-1, Cyrix 6x86), protože v těchto systémech nasazení
akcelerátorů dalších generací už nepřináší větší nárůst rychlosti oproti první generaci.
Programová rozhraní pro grafické adaptéry
Moderní grafické
-
14
-
2.2.3
Grafické akcelerátory 3. generace
Tato generace představuje grafické akcelerátory, které se začaly vyrábět zhruba před rokem. Mezi ně patří 3Dfx
Voodoo 3, Matrox G400, NVIDIA RIVA TNT 2, S3 Savage4 a ATI Rage 128. Běžně jsou osazovány již 32 MB
grafické paměti umožňujícím provoz aplikací a her ve vysokých rozlišeních v 32-bitové barevné hloubce. Pro
plné využití jejich výkonu je ovšem nutné použití rychlých procesorů řádu Pentium II nebo Pentium III, a ale-
spoň 64 MB systémové paměti. Tyto čipy již začínají nabízet výkon srovnatelný s běžnými pracovními stanice-
mi. Současná cenová akcelerátorů této generace je od 2000,- do 7000,- Kč včetně DPH.
2.2.4
Grafické akcelerátory 4. generace
Do této generace můžeme zařadit nejnovější grafické akcelerátory vyrobené v posledních měsících (nVidia Ge-
Force a S3 Savage) a další s velkým napětím očekávané čipy. Za všechny jmenujme alespoň výrobky osazené
nVidia GeForce 2 GTS, S3 Savage 2000, Matrox G800, 3Dfx Voodoo 4, ATI Rage 6 a Bitboys Glaze 3D. Tyto
adaptéry svými parametry postupně snižují rozdíl mezi běžnými grafickými adaptéry a špičkovými grafickými
akcelerátory popsanými dále. Některé z těchto akcelerátorů umožňují provádět i hardwarovou akceleraci výpočtů
světelného modelu a geometrických transformací (podrobnější informace lze nalézt v článku [56]), tedy technik,
které byly doposud k dispozici výhradně u špičkových grafických akcelerátorů, určených pro profesionální pou-
žití. Zajímavostí zbrusu nového akcelerátoru GeForce 2 GTS je kvalitní stínování, založené na výpočtu osvětlení
pro každý bod zvlášť (per pixel shading), obdobné Phongovu stínování. Tyto akcelerátory jsou standardně osa-
zovány 32 MB. Některé ovšem budou podporovat kapacity až do 128 MB grafické paměti. Současná cenová
relace těchto akcelerátorů je zhruba od 5000,- do 12000 Kč včetně DPH.
2.2.5
Špičkové grafické akcelerátory
V současné době jsou na trhu vedle běžných adaptérů, určených pro obecné použití, k dostání i grafické akcele-
rátory špičkových parametrů pro profesionální použití v pracovních stanicích. Tyto akcelerátory jsou osazovány
až 96 MB grafické paměti a obsahují ovladače pro podporu profesionálních modelovacích, CAD a dalších sys-
témů (Autocad, SoftImage 3D, Microstation, 3D Studio Max atd.). V těchto aplikacích jsou schopny dosáhnout
několikanásobně většího výkonu a kvality obrazu, než běžné akcelerátory. Obvykle jsou schopny na hardwarové
úrovni (kromě funkcí rasterizace, které jsou podporované běžnými akcelerátory), provést i výpočet světelného
modelu, geometrických transformací a další funkce, které běžně musí počítat systémový procesor. Tomu všemu
ovšem pochopitelně odpovídá i několikanásobně vyšší cena. Rozdíl mezi těmito špičkovými grafickými akcele-
rátory a grafickými akcelerátory pro běžné použití se ale postupně zmenšuje.
2.3
Architektura grafických adaptérů
2.3.1
Bloková struktura
Schéma typického grafického akcelerátoru je na následujícím schématu:
Programová rozhraní pro grafické adaptéry
Moderní grafické
-
15
-
Grafický
procesor
Sběrnice PCI
nebo AGP 2x/4x
MPEG /
DVD dekodér
Lokální
paměť
Lokální
paměť
Lokální
paměť
DAC
převodník
TV převodník
Výstup na
monitor
Vstup videa
nebo DVD
TV
výstup
Vnitřní sběrnice
VGA BIOS
Obrázek 12 –Schéma nejdůležitějších prvků typického grafického akcelerátoru
Jádrem grafického akcelerátoru je grafický procesor, poskytující akceleraci vykreslovacích funkcí. Grafický
procesor komunikuje s ostatními částmi grafického adaptéru, především pak s lokální pamětí. Ta bývá uložena
obvykle v jednom nebo více paměťových modulech (obvykle typu SDRAM, SGRAM, VRAM nebo DRAM).
Primárním účelem této paměti je prostor pro obrazový rámec. Dále zde mohou být uložena data pro výpočet
vykreslované scény. Typickým příkladem jsou textury. Uložení těchto dat v lokální paměti je výhodné tím, že
grafický procesor k těmto datům může přistupovat bez zátěže systémového procesoru nebo sběrnice. Grafický
procesor pro vnitřní komunikaci s pamětí používá vnitřní sběrnici. Grafický akcelerátor je obvykle vložen do
slotu sběrnice PCI nebo AGP. Tím je umožněna komunikace se systémovým procesorem, přes systémovou
sběrnici. Obvyklou výbavou je také dekodér videa MPEG nebo DVD. Ten umožňuje přehrávat video sekvence
bez nutnosti zatěžovat jejich dekódováním systémový procesor. Některé adaptéry navíc obsahují konektor pro
vstup DVD a MPEG přehrávačů nebo jiných zařízení. Každý grafický adaptér obsahuje převodníky pro výstup
vypočítaného obrazu. V současné době je nejpoužívanější výstup pro klasická analogová zařízení (např. pro
monitor). Některé výrobky obsahují navíc konektor TV výstup umožňující sledování obrazu na televizi. Tím
nabízejí zajímavou možnost pro provoz multimediálních aplikací a her. Pro tento druh zobrazení musí být gra-
fický adaptér vybaven odpovídajícími převodníky (DAC, TV převodník). Novinkou jsou speciální převodníky
určené pro připojení plochých digitálních displejů. Adaptéry podporující i tento výstup nejsou zatím příliš běžné,
stejně jako odpovídající displeje, které jsou zatím výrazně dražší než klasické CRT monitory. Programové vyba-
vení obsahující systém VGA a VESA BIOS pro zachování kompatibility se standardy VGA a VESA je uložen
v paměti VGA BIOS. Ta bývá typu ROM. Některé novější grafické adaptéry podporují přepis této paměti (ob-
vykle bývá typu Flash EPROM) umožňující případnou aktualizaci systému VGA BIOS.
Programová rozhraní pro grafické adaptéry
Moderní grafické
-
16
-
2.3.2
Rozhraní AGP
V současné době většina dnešních vyráběných grafických adaptérů používá rozhraní AGP (Accelerated Graphics
Port). Grafické akcelerátory pro sběrnice PCI se dodávají už jen pro účely upgradu současných systémů bez slotu
AGP. Sběrnice PCI není AGP nahrazena. Místo toho technologie AGP přidává další, nezávislé vysokorychlostní
rozhraní pro grafický adaptér. Základní desky podporující tuto technologii mají kromě standardních PCI slotů
ještě navíc jeden AGP slot. Schématická návaznost systémové sběrnice PCI, sběrnice AGP, procesoru a čipové
sady základní desky je na následujícím obrázku.
Obrázek 13 – Příklad návaznosti rozhraní AGP v systémech založeném čipové sadě Intel 440BX
Grafické podsystém založený na rozhraní AGP nabízí oproti PCI samé výhody:
•
Větší propustnost
Ta je umožněna vyšší přenosovou rychlostí (až 1 GB za sekundu u AGP 4x) oproti PCI (136 MB za sekundu).
Vzhledem k tomu, že rozhraní AGP je nezávislé na sběrnici PCI, při jejím použití tedy nedochází k zatěžování
systémové sběrnice PCI. Ta je k dispozici pro ostatní zařízení (pevný disk, CDROM nebo DVD mechanika,
síťový adaptér, zvuková karta apod.).
•
Možnost přímé práce s texturami přes AGP (AGP texturing)
Textury není nutné nahrávat do lokální paměti grafického akcelerátoru. AGP obsahuje mechanismus, kterým
může grafický akcelerátor přistupovat k texturám uloženým v systémové paměti stejně snadno, jako přistupuje
k texturám uloženým ve své paměti. Pro přenos textur do grafického akcelerátoru není nutná účast procesoru.
Není také nutné přenést celou texturu do paměti grafického akcelerátoru, ale je možné z ní přečíst jen ty body,
Programová rozhraní pro grafické adaptéry
Moderní grafické
-
17
-
které jsou potřebné pro výpočet scény. Takto je možné v levnějších systémech používat méně paměti na grafic-
kém akcelerátoru. Výkon je pak ovšem menší, protože grafický procesor je schopen ke své lokální paměti při-
stupovat zhruba 2 – 5 rychleji. Přestože textury nemusí být v paměti uloženy v jednom souvislém bloku, AGP je
schopno překladu adres tak, že se grafickému procesoru jeví, jakoby byly v jednom souvislém bloku. Princip
této techniky je obdobný stránkovacímu mechanismu u virtuální paměti. Segmenty paměti pro textury AGP jsou
dynamicky alokovány operačním systémem.
•
Kompatibilita
Aplikace určené pro sběrnici PCI budou fungovat i na AGP. V každém případě se zrychlení projeví při ukládání
textur do lokální paměti grafického akcelerátoru. Pokud aplikace počítá s AGP, může dojít ke zvýšení výkonu.
Často použité textury jsou pak uloženy do lokální paměti grafického akcelerátoru a ostatní zůstanou v systémové
paměti. Odpadá nutnost výměny textur, kdy je kapacita lokální paměti vyčerpána.
•
Možnost použití integrovaného grafického podsystému
Výkon a možnosti sběrnice nabízí možnost umístit solidní grafický akcelerátor přímo na základní desku. Výkon
sice takto realizovaného grafického podsystému sice nebude špičkový, ale pro běžné aplikace postačí. Příkladem
je firma Intel, která nabízí čipové sady Intel 810 s tímto řešením pro levné systémy založené na procesorech
Celeron. Na základní desce je navíc umístěna vyrovnávací paměť o velikosti 4 až 8 MB pro nejčastěji používané
textury umožňující zvýšit výkon. Zajímavé řešení se opírá o možnost přímé práci s texturami nabízené sběrnicí
AGP a podporuje ovladače DirectX i OpenGL. Nevýhodou je ale nemožnost budoucího rozšíření takového sys-
tému samostatným (a výkonnějším) grafickým adaptérem. Důvodem je právě obsazení sběrnice AGP integrova-
ným adaptérem.
2.4
Vlastnosti a možnosti grafických adaptérů
2.4.1
Nejdůležitější charakteristiky
Barevná hloubka (color depth)
Všechny grafické akcelerátory jsou schopné pracovat v režimu 16-bitové barevné hloubky. Při použití 32-bitové
barevné hloubky (režim pravých barev), vyžaduje vyšší výkon a větší paměť grafického akcelerátoru, protože je
nutné přenášet a pracovat s texturami dvojnásobné velikosti. Vizuální kvalita zobrazovaných dat je ovšem o něco
vyšší.
Rychlost vykreslování (fill rate)
Rychlost vykreslování (fill rate) zhruba vypovídá o obecné kvalitě grafického adaptéru, přestože nedává přesný
obraz o výkonu grafického adaptéru. Rychlost vykreslení se dá odvodit z použité frekvence grafického akcelerá-
toru, počtu nezávislých převodníků, šířky pásma a samozřejmě z vlastností samotného grafického čipu. Výkon
grafického akcelerátoru je ovšem lepší posoudit otestováním v aplikacích, které hodláme používat, než spolehnu-
tím se na tyto teoretické hodnoty .
Programová rozhraní pro grafické adaptéry
Moderní grafické
-
18
-
Velikost grafické paměti
Instalovaná paměť na grafickém akcelerátoru má velmi významný vliv na celkový výkon grafického systému.
Paměť grafického akcelerátoru se využije jednak pro obrazové rámce (potřebné jsou obvykle dva až tři), zbytek
se využívá pro paměť textur. Pokud aplikace potřebuje více textur, než je velikost této paměti, musí se tyto textu-
ry trvale přenášet přes sběrnici PCI nebo AGP. Tímto ovšem klesá výkon, protože k texturám umístěným
v lokální paměti grafického akcelerátoru, je grafický procesor schopen přistupovat několikanásobně rychleji
(řádové několik GB za sekundu). Také vnitřní paměťová sběrnice grafických akcelerátorů se vyvíjí od 128 bito-
vého k 256-bitovému rozhraní.
V současné době se používá technika zdvojené sběrnice (dual bus), která spočívá v rozdělení sběrnice na vstupní
a výstupní. Vstupní přijímá grafické instrukce a data na výstupní jsou ve stejném cyklu posílány výsledky. Sou-
časný běžný standard velikosti používané paměti, 32 MB je plně dostatečný pro provoz 3D aplikací v režimech
1024 na 768 v 32-bitové barevné hloubce.
Převodník obsahu grafické paměti na analogový výstup (DAC převodník)
Úkolem tohoto převodníku je převod digitálních informací uložených v paměti grafického adaptéru a analogo-
vým CRT monitorem. Čím vyšší je šířka pásma převodníku, tím větší počet obrazových bodů může být zobrazen
na CRT monitoru každou sekundu, proto je tedy rychlý převodník důležitý pro vyšší obnovovací frekvence.
Současné rychlé převodníky jsou schopné zobrazovat rozlišení až 2048x1636 obrazových bodů (běžná šířka
pásma je 300 Mhz). Některé grafické adaptéry navíc nabízejí převodníky pro televizní/video výstup.
Digitální výstup
Při použití digitálních displejů není DAC převodník potřeba. Místo toho tyto displeje potřebují podporu digitál-
ního výstupu. Tento převodník ovšem nepatří mezi standardní výbavu většiny dnešních grafických adaptérů.
Maximální velikost podporovaných textur
Tato velikost je důležitá pro tvorbu detailních a realistických 3D scén. Současné čipy grafických akcelerátorů
nabízejí maximální velikost textur 2048 na 2048 obrazových bodů, což je vhledem k současným rozlišením a
pamětí grafických akcelerátorů více jak dostačující.
2.4.2
Standardní podporované funkce
Všechny, v dnešní době běžné grafické akcelerátory, podporují tyto funkce:
•
vykreslování trojúhelníků (triangle setup),
•
konstantní a Gouradovo stínování (Constant shading, Gourad shading)
•
mapování textur s perspektivní korekcí (texture mapping),
•
16-bitová nebo 32-bitová paměť hloubky (16-bit/32-bit Z buffer),
•
míchání průhledných vrstev (alpha blending),
Programová rozhraní pro grafické adaptéry
Moderní grafické
-
19
-
•
bilineární interpolaci (bilinear interpolation),
•
mipmapy (mipmapping),
•
barevnou redukci (dithering).
Všechny tyto podporované funkce jsou vysvětleny v kapitole Důležité pojmy (1.2.)
2.4.3
Další podporované funkce
Mezi další zajímavé funkce a možnosti, které některé dnešní 3D akcelerátory podporují patří:
•
víceprůchodové nanášení textur (multitexturing),
•
komprese textur (texture compression),
•
hrbolovité mapování (bump mapping),
•
mapování prostředí (enviroment mapping),
•
paměť šablony (stencil buffer),
•
různé techniky pro vyhlazování hran nebo celého obrazu (antialiasing, full screen antialiasing),
•
paměť T (T buffer),
•
mlhové efekty (fog effects),
•
přehrávání videa DVD (DVD playback),
Podpora víceprůchodového nanášení textur umožňuje nanášet na jeden objekt více textur najednou. Výhodou
oproti nanesení postupně v několika krocích je v rychlosti zpracování. Grafické akcelerátory podporující tuto
možnost jsou obvykle schopny tuto operaci provést srovnatelně rychle, jako při nanesení pouze jedné textury.
Této techniky lze například použít pro tvorbu světelných efektů (viz následující obrázek). V současné době vět-
šina 3D čipů má k dispozici dva paralelní převodníky pro víceprůchodové nanášení textur, které byly poprvé
uvedeny na čipech Voodoo II. V aplikacích potřebujících více průchodů, se původně obrazový bod počítal ve
dvou či více průchodech. Tyto průchody lze ovšem počítat paralelně a tudíž i dvojnásobnou rychlostí, pokud čip
podporuje víceprůchodové nanášení textur. Pokud aplikace pro výpočty bodů potřebuje jen jeden průchod, tak
každý z tìchto převodníku může vytvářet jiný bod a tudíž urychlit vykreslování.. Současné čipy mají alespoň dva
převodníky pro více průchodů. V blízké budoucnosti již budou běžné čtyři a více převodníků.
Programová rozhraní pro grafické adaptéry
Moderní grafické
-
20
-
Obrázek 14 - Textura šachovnice, osvětlená barevným vzorkem. Moderní grafické akcelerátory jsou schopné
vytvořit podobné scény v jednom průchodu
Komprese textur umožňuje ušetřit paměť grafické i systémové paměti použitím ztrátové komprese. Další výho-
dou je možné zvýšení výkonu, protože textury jsou posílány po sběrnici v komprimované podobě. Patentována
technologie nazvaná S3TC byla použita poprvé u akcelerátoru S3 Savage3D, a je nyní k dispozici jako součást
DirectX a OpenGL. Kompresní poměr je zde od 1:4 do 1:6. Kvalita obrazu s použitím komprese je přitom téměř
k nerozeznání od případu, kdy je obraz tvořen bez použití této technologie. Navíc se nabízí možnost použít textu-
ry dvojnásobného rozlišení. Při použití komprese textur v takovémto případě dosáhneme větší obrazové kvality
při stejných paměťových nárocích. V současné době tuto technologii používají i nejnovější grafické adaptéry
GeForce a GeForce 2 GTS od firmy nVidia.
Více informací lze nalézt na adrese [55].
Hrbolovité mapování (bump mapping) - tato technologie umožňuje vidět realisticky zakřivené povrchy s urči-
tými efekty namísto obyčejných jednotvárných povrchů. Tím by se měl dramaticky zlepšit vizuální dojem z 3D
scén. To se týká především zlepšení kvality obrazu při použití osvětlení. Příkladem můžou být vlny na vodní
hladině. Technologie zhruba řečeno spočívá na přidání další textury, ve které jsou zaznamenány výšky jednotli-
vých bodů. Většina čipů v současné době realizuje hrbolovité mapování přidáním dalšího průchodu, stejně jako
při víceprůchodovém nanášení textur, výsledek ale není dokonalý a nenabízí různé další možnosti a efekty.
Technika hrbolovitého mapování je již součástí Direct3D. Jak půjde vývoj dále, budou muset zřejmě všichni
výrobci grafických akcelerátorů přijít se svými řešeními a zahrnout tuto technologii do svých čipů.
Čtenáře s hlubším zájmem o tuto problematiku odkazuji na články [47] a [48].
Programová rozhraní pro grafické adaptéry
Moderní grafické
-
21
-
Obrázek 15 – Zeměkoule vytvořená mapováním textur bez použití technologie hrbolovitého mapování (vlevo)
Obrázek 16 – Zeměkoule vytvořená mapováním textur s použitím technologie hrbolovitého mapování (vpravo)
Obrázek 17 – Část textury použitá pro vytvoření povrchu zeměkoule (vlevo)
Obrázek 18 – Část textury s výškami jednotlivých bodů povrchu (vpravo)
Mapování prostředí (enviroment mapping) může ještě dále vylepšit vizuální kvalitu scény přidáním různých
odrazů a stínů na lesklých površích, které stejně jako v reálném světě vznikají vlivem objektů okolního prostředí.
Obvykle se realizují mapováním textur.
Paměť šablony umožňuje definovat masku, podle které jsou prováděny určité efekty s vytvářeným obrazem.
Nejjednodušším příkladem je povolení nebo zakázání obrazu. Tak může dojít ke zvýšení rychlosti výpočtu, pro-
tože se nemusí počítat všechny body. Ukázku využitelnosti této technologie je zachycují následující obrázky. Ty
demonstrují vytvoření scény viděné z kokpitu letounu.
Programová rozhraní pro grafické adaptéry
Moderní grafické
-
22
-
Obrázek 19 – Bitová maska, určující které body mají být vypočítávány a které ne (vlevo)
Obrázek 20 – Textura použitá pro vytvoření kokpitu letounu (vpravo)
Obrázek 21 –Vypočítávaná scéna. Při použití masky jsou vypočítávány pouze body, které nejsou zakryty maskou
(vlevo)
Obrázek 22 – Konečná verze daná sloučením textury masky a vypočítané scény (vpravo)
Čtenáře s hlubším zájmem o tuto problematiku odkazuji na články [41], [42] a [52].
Paměť T je zajímavá technologie. Poprvé ji použila firma 3Dfx. Řeší problém vyhlazování hran. Při pohybu
objektů, u kterých není vyhlazování řešeno, je viditelná trhanost a objekty mohou mírně měnit svou velikost.
Potlačení těchto jevů je sice dostupné i na dnešních grafických akcelerátorech, ovšem používané postupy potře-
bují buď příliš mnoho procesorového času nebo výkonu grafického akcelerátoru. Výsledek navíc není příliš
přesvědčivý a pokles rychlosti vykreslování je dramatický. Paměť T umožňuje jak vyhlazovaní celého obrazu
Programová rozhraní pro grafické adaptéry
Moderní grafické
-
23
-
(full screen spatial antialiasing), tak vyhlazování hran při animaci (motion blur antialiasing). Změna v kvalitě
obrazu je výrazná. Vše má přitom na starosti grafický procesor, zátěž systémového procesoru je minimální, takže
zvětšení kvality obrazu není na úkor rychlosti vykreslování. Způsob těchto technik spočívá – velmi jednoduše
řečeno – v tom, že obraz je ve skutečnosti vykreslen několikrát a výsledný snímek pak vznikne jejich sloučením.
Paměť T má však řadu dalších využití, s jeho pomocí lze zobrazit např. měkké stíny (soft shadows) a odrazy
(reflectance blur). Měkké stíny nemají ostré okraje, ty jsou naopak rozmazané a výsledek tak více odpovídá
skutečnosti. Měkké odrazy zase lépe vystihují povahu materiálu. Zatímco u zrcadlových ploch je odraz světla
dokonalý, u matnějších ploch jsou dobře viditelné pouze odrazy blízkých objektů, odraz vzdálenějších je rozma-
zaný. Další využití představuje přizpůsobení obrazu situaci, kdy se náš zrak zaměří na určitý objekt (hloubka
ostrosti). Ten zůstane zachován, zatímco okolí vnímáme rozostřené. Výsledkem použití těchto technik by měl
být ještě větší zážitek při zobrazení prostorových scén, především v počítačových hrách. Obraz už nebude půso-
bit tak uměle a bude se daleko více blížit skutečnosti.
Čtenářům s hlubším zájmem o tuto problematiku doporučuji přečíst článek [45].
Programová rozhraní pro grafické adaptéry
Grafická rozhraní
-
24
-
3
Grafická rozhraní
3.1
Úvod
V současné době vývoj grafických a multimediálních aplikací značně usnadňují specializované grafické knihov-
ny. Tyto knihovny bývají většinou zaměřeny na užší, specifický okruh činností. Jejich výhodou je, že jsou větši-
nou naprogramovány velice efektivně. Proto je při jejich použití obvykle zaručen spolehlivý chod a výkon apli-
kací. V oblasti multimedií, zejména pak v oblasti počítačové grafiky jsou nejrozšířenější OpenGL, a to na všech
platformách a DirectX na systémech s Windows. Obě rozhraní se postupem času staly průmyslovým standardem
pro výrobce hardwaru.
3.2
Grafická rozhraní v jednotlivých systémech
3.2.1
Systémy IBM-PC kompatibilní s operačním systémem MS-DOS
Systém DOS je již zastaralý. Používají ho starší aplikace, běžící na stávajícím hardwaru a softwaru a některé
speciální aplikace. Při programování je možné použít služeb systému BIOS, který se ovšem v praxi díky omeze-
ným možnostem a nízkému výkonu takřka nepoužívá. Programátor je nucen zajistit grafické zobrazování přímou
manipulací s registry a pamětí grafického adaptéru. Část obrazové paměti je přitom mapována do reálné paměti
počítače. Tento postup je navíc použitelný jen pro adaptéry standardu VGA, kde jsou adresy registrů, obrazové
paměti, způsob manipulace s nimi, jasně definované a postup je stejný u všech grafických adaptérů. Počet barev
je omezen na 256 barev a maximální dosažitelné rozlišení je 640 na 400 bodů.
Novější grafické adaptéry nabízejí ovšem vyšší rozlišení a barevné hloubky odpovídající novějšímu standardu
SVGA. Jednotlivé adaptéry se ovšem navzájem odlišují způsobem práce s registry. Pro grafickou aplikaci bylo
tedy nutné vytvořit pro konkrétní grafický adaptér speciální ovladač.
Situace se zlepšila zavedením standardů VESA, které nabízejí grafické rozhraní, umožňující univerzální a jed-
notný systém práce se všemi adaptéry, které jsou vybaveny ovladačem VESA. Umožňuje snadné nastavení gra-
fického režimu, mapování částí zobrazovacího rámce do systémové paměti, nastavení pozice zobrazovacího
rámce v paměti (umožňující plynulý pohyb obrazu). Novější implementace standardu VESA, verze 2.0 umožňu-
je mapovat celou grafickou paměť do adresového prostoru procesoru v chráněném režimu a tak práci značně
zjednodušit možností lineární adresace celého obrazového rámce. Tato implementace je dodávána jako rozšíření
společně se systémem VIDEO BIOS i u nejnovějších grafických akcelerátorů. Důvodem je zachování kompati-
bility s velmi širokou aplikační základnou aplikací DOS.
Programová rozhraní pro grafické adaptéry
Grafická rozhraní
-
25
-
3.2.2
Systémy s operačním systémem Microsoft Windows
Vzhledem k tomu, že se tato platforma v současné době v různých aplikacích počítačové grafiky nejvíce použí-
vá, zaměříme se na její grafické možnosti podrobněji.
Současné operační systémy Windows obsahují rozhraní umožňující použití 2D i 3D grafiky a přehrávání videa.
K dispozici jsou rozhraní používající vrstvy různých úrovní, s různými možnostmi a výkonem. Nejběžnější jsou
přímo integrované v systému, je možné použít i rozhraní třetích výrobců, které obvykle navazují na nižší vrstvu -
ovladače hardwaru. Architektura a návaznost jednotlivých vrstev a rozhraní je zobrazena na obrázku. Pro vývo-
jáře aplikací jsou použitelná rozhraní nad obecnou vrstvou grafického ovladače (Display Driver Interface –
DDI). Tyto jsou totiž nezávislé na použitém grafickém adaptéru. Následuje popis nejdůležitějších rozhraní a
obrázek, zobrazující návaznost a hiearchii jednotlivých vrstev a rozhraní, které je spojují.
Obrázek 23 - Architektura grafických rozhraní systémů Windows
Rozhraní GDI
Je vhodné pro aplikace, které používají obecné 2D grafické prvky, obrazové mapy, fonty apod. Typickým pří-
kladem aplikace může být textový editor. Práce s obrazovými mapy, je nezávislá na použitém adaptéru. Pro
moderní aplikace používající 2D grafiku je nevýhodou nemožnost využít plně výkonu a možností adaptéru.
Zcela vyloučena je možnost použít prvků 3D akcelerace pro realizaci 2D grafiky (například paměti textur). Jedná
se o původní a nejobecnější rozhraní Windows.
Rozhraní DirectDraw
Pro aplikace a systémové komponenty, které jsou především rychle vykreslují dvourozměrné bitové mapy, je
vhodné použít rozhraní pro rastrovou grafiku DirectDraw. Rozhraní je schopné využít schopností 2D akceleráto-
rů, jako je hardwarové vykreslování ploch. Možný je i přímý přístup do video paměti a přepínání stránek. Roz-
hraní je často užívané hrami a multimediálními aplikacemi. Všechny nové grafické adaptéry disponují možnost-
Programová rozhraní pro grafické adaptéry
Grafická rozhraní
-
26
-
mi a ovladači umožňující rychlý chod aplikací využívajících toto rozhraní. Rozhraní je nezávislé na použitém
hardwaru. Koncepcí je rozhraní podobné programování pod systémem DOS, který umožňoval přímý přístup k
hardwaru. Aplikace používající toto rozhraní musí zjistit, které funkce jsou podporovány a ty potom využít. Je
nutné se přizpůsobit konkrétní barevné hloubce podporované konkrétním grafickým adaptérem.
Rozhraní Direct3D
Pro běžné aplikace (multimediální, aplikace založené na VRML, hry) využívající 3D grafiku se ve Windows
obvykle používá rozhraní Direct3D. Nabízí softwarovou implementaci 3D objektů a 3D zobrazovacího systému
s možností přímého využití 3D akcelerace grafického adaptéru. Podpora zahrnuje geometrickou transformaci,
osvětlení, rastrové operace. Samotné rozhraní má více vrstev, které umožňuje použít buď funkce pro obecnou
3D grafiku nebo přímo přistupovat k hardwaru (na bázi vrcholových bodů a polygonů). V tomto případě vývojář
používá vlastní systém vytváření zobrazovaní scény. Podporuje různé formáty 3D modelů, jejich čtení a ukládá-
ní. Dále je definován obecný model pro tvorbu 3D ovladačů, usnadňující výrobcům vytvářet produkty využívají-
cích toto rozhraní. Direct3D se opírá o vrstvu Direct3D Hardware Abstraction Layer (HAL), která implementuje
nejnižší 3D funkce podle specifických možností zařízení.
Rozhraní DirectX Media
Jedná se o standardní rozhraní firmy Microsoft zahrnuté v nových verzích DirectX. Doplňuje možnosti vrstev
DirectDraw a Direct3D (je na stejné úrovni), o možnost přehrávání video sekvencí. Přitom je využito případných
možností akcelerace dekódování videa grafickým adaptérem bez zatěžování systémového procesoru. Typickým
příkladem je využití možností grafických adaptérů s MPEG dekodérem. Zajímavá je i možnost v reálném čase
mapovat video sekvence jako textury 3D objektů.
Rozhraní Active Movie
Rozhraní navazuje na vrstvu DirectX Media a umožňuje přímé a snadné přehrávání široké škály formátů video
sekvencí. Nahrazuje a doplňuje původní rozhraní Microsoft Video for Windows. Kromě nativního formátu
Microsoft Video (AVI) podporuje také formáty ostatních výrobců – například Motion Pictures Expert Group
(MPEG), Apple QuickTime (MOV), a je možné doplnit vlastní přidáním dekodéru. Podporuje i přehrávání video
sekvencí z Internetu a jeho architektura je dále rozšiřitelná. Rozhraní disponuje i možností vytváření videa a
efektů.
Rozhraní OpenGL ve Windows
Pro své vynikající vlastnosti, jednoduchost použití, přenositelnost, tradici díky pracovním stanicím firmy SGI, i
dostupnosti materiálů o tomto rozhraní a dalším výhodám, bylo toto rozhraní importováno i do světa stále vý-
konnějších osobních počítačů. Využití pod Windows najde jednak v profesionálních aplikacích jako jsou
CAD/CAM, 3D modelovací systémy apod., z nichž některé byly importované právě ze světa systémů Unix sta-
nic firmy SGI do prostředí Windows NT. Co nejlepší podpora a implementace nejpoužívanějších funkcí obou
rozhraní je nutnou podmínkou úspěchu jakéhokoliv nově navrženého adaptéru. Ve Windows 95 je třeba nainsta-
lovat Service Pack 1, ve Windows 98, Windows NT 4, a Windows NT 2000 je již rozhraní podporováno. Je
ovšem nutné od výrobce obdržet ovladač OpenGL pro daný grafický akcelerátor, který není standardní dodávkou
Programová rozhraní pro grafické adaptéry
Grafická rozhraní
-
27
-
všech grafických akcelerátorů. Optimálně implementované ovladače OpenGL obvykle nepoužívají služeb Di-
rectDraw nebo Direct3D místo toho přistupují přímo k rozhraní ovladače hardwaru.
Rozhraní vrstvy hardwaru (Hardware Abstraction Layer - HAL)
Rozhraní DirectX API je postaveno na tenké hardwarově závislé vrstvě, oddělující specifické vlastnosti hardwa-
ru od vyšších. Služby tohoto rozhraní poskytují možnost získat informace, podporované vlastnosti, schopnosti a
charakteristiky použitého hardwaru. Tak lze zjistit, které funkce je grafický adaptér schopen hardwarově vyko-
nat.
Rozhraní vrstvy emulující hardware (Hardware Emulation Layer – HEL)
Vrstva emulující hardware (v obrázku označené jako Software Emulation) vykonává softwarovou emulaci funk-
cí, které hardware není schopen poskytnout. Tak je umožněno, aby aplikace fungovaly na jakémkoliv grafickém
adaptéru.
Ostatní rozhraní
Rozhraní dalších výrobců obvykle navazují na rozhraní ovladače hardwaru, případně na určitou vrstvu rozhraní
DirectX. Příkladem může být rozhraní Apple QuickTime pro přehrávání videa, rozhraní Scitech Direct GL
umožňující emulaci OpenGL pomocí volání funkcí Direct3D, pro starší grafické akcelerátory bez nativní podpo-
ry OpenGL, a další.
Některé rozhraní používají vlastní ovladače hardwaru. Příkladem ještě v nedávné době nejčastěji používané
rozhraní Apple QuickDraw3D. Jednalo se o kompletní grafické rozhraní, umožňující přímou a jednoduchou
práci s 3D objekty a soubory. Přitom se opíralo o vlastní rozhraní vrstvy grafického hardwaru, nazvaném (QD3D
Rave). Toto ovšem v současné době ustupuje rozhraním Direct3D a OpenGL.
Někteří výrobci grafických adaptérů nabízejí vlastní rozhraní, umožňující využití jejich produktů aplikačními
programátory. Nejznámější je přitom rozhraní GLIDE, pro grafické akcelerátory řady Voodoo firmy 3Dfx. Exis-
tují ovšem i další, jako je rozhraní METAL grafických akcelerátorů řady Savage firmy S3. Mimo oblast počíta-
čových her ovšem nenacházejí větší uplatnění. V současné době se tyto rozhraní již téměř nepoužívají.
3.2.3
Systémy Linux
Grafické vykreslování je založena na použití okenního systému X-Window a grafické knihovny X11. Jedná se o
systém výhradně určený pro 2D grafiku. Nedávno společnost Silicon Graphics oznámila uvolnění zdrojového
kódu GLX pro sdružení Open Source, a otevřela tak dveře k hardwarové akceleraci grafiky pomocí rozhraní
OpenGL pro platformu Linux a jiných systémů založených na operačním systému Unix. GLX je softwarová
vrstva používaná pro integraci OpenGL a systémů X-Window, která zprostředkovává vykreslování 3D grafiky.
Tímto krokem by se mohl Linux v blízké budoucnosti stát i alternativní platformou pro pracovní stanice.
Standard OpenGL se nedodává společně s jádrem a není přímo podporován. Změna by měla nastav po zavedení
nových systémů s jádrem XFree86 4.0.0. a vyššími. Jádro obsahuje softwarovou implementaci OpenGL (založe-
né na produktu MESA) a nabízí hardwarovou akceleraci pro akcelerátory ATI, Matrox a NVIDIA a 3Dfx. Jádro
Xfree86 je nabízeno zdarma.
Programová rozhraní pro grafické adaptéry
Grafická rozhraní
-
28
-
Systémy Linux založené na starších verzích jádra je možné rozšířit použitím knihovny MESA. Jde o produkt
dodávaný zdarma, velmi podobný OpenGL (nedá se totiž říci, že je kompatibilní s OpenGL, protože jeho autor,
Brian Paul neobdržel od firmy SGI potřebnou licenci) zpřístupňující OpenGL na operačním systému Linux.
Podporuje systém X11 a většinu Unixů. Zatím ovšem až na výjimky (např. akcelerátory 3Dfx) prakticky nepod-
poruje grafické akcelerátory. Existuje i na systémech Amiga, Windows, Macintosh, Next a BEOS. Lze ale do-
konce využít i v chráněném režimu systémů DOS.
V současné době některé firmy jako je například firma Metro-Link dodává komerční řešení ovladačů hardwaro-
vé podpory grafických akcelerátorů pro Linux založené na vlastních ovladačích.
3.3
Rozhraní OpenGL
V rozsahu této práce není možné přinést podrobnější popis problematiky OpenGL. Pru hlubší seznámení s tímto
rozhraním autor doporučuje prostudovat dokumentaci na Internetových stránkách. Adresy na nejdůležitější
z nich jsou uvedené v kapitole 12.1.1.
OpenGL je grafická knihovna (API) vyvinutá společností SGI, původně pro operační systém IRIX (jedná se o
klon Unixu). Vychází z velmi úspěšné grafické knihovny GL IRIS, která v 80. letech umožnila pracovním stani-
cím firmy SGI stát se platformou pro profesionální počítačovou grafiku. Na rozdíl od knihovny GL IRIS byla
knihovna OpenGL navržena tak, aby byla přenositelnější a méně závislá na konkrétní platformě.
Knihovna patří mezi rozhraní nižší úrovně. Představuje vrstvu, která je nezávislá na možnostech grafického
podsystému. Nepodporuje práci s grafickými objekty a soubory. Tato vrstva obsahuje přibližně 250 příkazů,
umožňující popis grafických objektů a provedení operací k vytvoření konečného obrazu. Je k dispozici pro jazy-
ky C/C++, Java, Fortran, ADA.
První verze této knihovny, implementace 1.0, se používá od roku 1992. Novější verze jsou zpětně kompatibilní
se staršími. S rostoucím výkonem personálních počítačů našla své uplatnění i na domácích systémech a byla
přenesena na řadu operačních systémů (Windows, Linux, pracovní stanice). V současné době můžeme Open-
GL považovat za průmyslový standard grafického rozhraní v oblasti počítačové grafiky. O tom svědčí
široká podpora výrobců grafických akcelerátorů, uzpůsobujících jejich možnosti tomuto standardu. Exis-
tují řádově tisíce grafických aplikací, které OpenGL používají. Dnes jej nalezneme téměř všude od her-
ních konzol (Sony Playstation 2), přes osobní počítače až ke špičkovým pracovním stanicím.
Grafická knihovna (API) OpenGL má za úkol vygenerovat a zobrazit požadovanou grafickou scénu. Pokud
předpokládáme nasazení v 3D grafice, umožňuje zejména: řešit viditelnost prostorových objektů pomocí paměti
hloubky, provádět stínování, mapovat textury, pracovat s průhlednými vrstvami, vyhlazovat hrany, barevnou
interpolaci, provádět výpočet křivek, vytvářet atmosférické efekty (atmospheric effects), provádět geometrické
transformace v maticové formě (viewing and modeling transformations), použití dvojité obrazové paměti pro
plynulou animaci (double buffering), generovat grafická primitiva a další.
Zajímavým rysem je podpora architektury klient server a síťové zpracování. Tak je možné, že aplikace (klient)
posílá jen základní grafická data, jako jsou souřadnice grafických primitiv a barvy na grafický server, který po-
žadovaná data zobrazí (provede rasterizaci). Rasterizace vytváří obrazové body a závisí na aktuálním nastavení
OpenGL (OpenGL state). Stav je dán například povolením nebo zakázáním používání textur, mlhových efektů,
světel apod. Normálně klient i server běží na jednom počítači. Tento rys byl zamýšlen pro levné osobní počítače,
Programová rozhraní pro grafické adaptéry
Grafická rozhraní
-
29
-
které mohou posílat své požadavky výkonné pracovní stanici. Při výkonu současných grafických adaptérů je
takovéto použití ovšem vzácné.
OpenGL podporuje okamžitý (immediate mode) a předpočtený režim (display list execution mode) pro grafické
operace. Při standardním, okamžitém režimu, aplikace posílá OpenGL požadavky, který je ihned provádí. Takto
je možno zajistit rychlou odezvu pro běžné aplikace.
V předpočteném režimu jsou grafické příkazy ukládány do seznamu příkazů (call list). Výhodou je zrychlení
používání často používaných objektů, protože seznam příkazů může být vícekrát používán.
Za optimálních podmínek OpenGL pouze vyvolává příslušné funkce na hardwarové úrovni. Pokud konkrétní
funkce jádra OpenGL (nikoli ovšem extense, viz dále) není hardwarově podporována, automaticky se emuluje
softwarově. Tento postup umožňuje dosáhnout maximálního výkonu při současném zachování hardwarové ne-
závislosti.
Je také zaručena funkčnost všech aplikací na libovolném konfiguraci hardwaru a softwaru, podporující OpenGL.
Toto je velká výhoda narozdíl od Direct3D (viz následující obrázek).
Aplikace
Ovladač OpenGL
Jak je funkce
podporována ?
Hardwarová
akcelerace
Softwarová
emulace
Grafické příkazy
Grafické příkazy
Aplikace
Které funkce
jsou podporované ?
Akcelerace
Direct3D HAL
Rozděl volání funkcí
Emulace
Direct3D HEL
Obrázek 24 –Aplikace založené na OpenGL pouze předávají grafické příkazy ovladači OpenGL, který automa-
ticky použije možností akcelerace grafického adaptéru. Aplikace se nemusí zajímat, na kterém grafickém adaptér
je spuštěna (vlevo)
Obrázek 25 – Aplikace na založené na Direct3D musí zjistit, které možnosti jsou v systému, na kterém jsou spuš-
těné k dispozici. Podle toho musí aplikace zvolit vlastní systém volání rozdělený mezi akcelerované a emulované
funkce (vpravo)
Standardní možnosti OpenGL je možno rozšířit pomocí tzv. extensí. Není ovšem zajištěno, že tyto extense bu-
dou k dispozici na všech implementacích. Před jejich použitím je proto programátor nucen otestovat zda jsou
k dispozici. V dalších verzích OpenGL se nejpoužívanější extense zahrnují přímo do standardu OpenGL.
Standard OpenGL je spravován skupinou ARB (Architecture Review Board). Ta také zajišťuje rychlou reakci
standardu na novinky v oblasti počítačové grafiky a grafických adaptérů. Zajišťuje také jeho další vývoj, nové
specifikace, extense, verze a testování. Ve skupině mají v současné době zastoupení firmy působící na poli počí-
Programová rozhraní pro grafické adaptéry
Grafická rozhraní
-
30
-
tačové grafiky 3DLabs, Compaq, Evans & Sutherland, Hewlett Packard, IBM, Intel, Intergraph, Microsoft,
NVIDIA a Silicon Graphics.
OpenGL, jako prostředí zcela nezávislé na konkrétní platformě, nepoužívá prostředky pro správu a práci s okny.
Obsahuje ale mechanismy a pomocné funkce, zajišťující styk se systémem správy oken. Na každé platformě je
nutné napsat vlastní kód, který toto umožňuje. Tohoto se dosahuje různými programovými knihovnami. Mezi
nejznámější patří knihovny GLX a TK na systémech X-Window, a knihovna GLW na platformách Win32. Na
některých platformách se také používá jednoduchá knihovna GLAUX. Tyto knihovny ovšem nejsou navzájem
kompatibilní, pro zajištění chodu aplikací musí programátor na každé platformě použít jiný systém volání. Pře-
nositelnost aplikací používajících OpenGL je tak omezena nutností psát jiný kód pro správu oken. Díky úsilí lidí,
soustředěné okolo Marka Kilgarda z firmy SGI byl vyvinut GLUT (OpenGL Utility Toolkit). Ten nabízí imple-
mentačně nezávislé volání pro práci s okny a některými vstupními zařízeními. Stejně jako OpenGL, je i GLUT
k dispozici zdarma na velkém množství platforem.
3.3.1
Platformy podporující OpenGL
OpenGL je podporován na všech pracovních stanicích s operačním systémem UNIX, je k dispozici standardně
na každém počítači s Windows NT and a Windows 95 OSR2 a Windows 98. Žádné jiné grafické rozhraní není
k dispozici na tak široké základně hardwarových platforem a softwarových prostředí. OpenGL funguje na všech
hlavních operačních systémech mezi nimiž je Mac OS, OS/2, UNIX, Win9x/ NT, Linux, OPENStep, Python,
BeOS a Sparc Solaris. Pracuje také se všemi hlavními systémy správy oken, mezi nimiž je Presentation Ma-
nager, Win32, and x/Window System. Funkce OpenGL lze volat z jazyků Ada, C, C++, Fortran, Java a je zcela
nezávislý na síťových protokolech a topologiích. Jednou s posledních zajímavých novinek je jeho vestavění do
herních konzol Sony Playstation 2.
3.3.2
Současný stav rozhraní OpenGL na PC
Ještě před dvěma lety, patřily grafické akcelerátory s ovladači s podporou OpenGL k výrobkům vyšší cenové
kategorie. S rostoucí podporou výrobců se OpenGL již stává samozřejmostí i u grafických akcelerátorů nižších
tříd. Značný vliv na tuto změnu měl velký zájem o počítačové hry, které využívají OpenGL k vytváření prostředí
především akčních her a různých simulátorů. To motivuje výrobce grafických akcelerátorů k zahrnutí OpenGL
do standardní výbavy programového vybavení.
Grafický akcelerátor nejnižší třídy s ovladačem OpenGL lze zakoupit již kolem 1300,- Kč (vybavená čipem
Verite 2200 a pamětí 8 MB pro sběrnici PCI nebo AGP). Tyto akcelerátory sice hardwarově nepodporují všech-
ny funkce OpenGL, a nabízí jen základní funkce pro rasterizaci. Pro účely běžných aplikací ovšem postačí, pro-
tože i takto odebírají značný čas procesoru potřebný pro výpočet scény.
Stávající ovladače grafických adaptérů dodávané s operačními systémy Windows tuto podporu zatím neobsahují.
K získání podpory akcelerovaných funkcí OpenGL je nutné nainstalovat ovladače OpenGL od výrobce získané
s instalačním softwarem grafického akcelerátoru nebo získané z Internetu. Na adrese www.glsetup.com je
ke stažení program, který zjistí, jaká grafický akcelerátor je v sytému nainstalovaný a podle toho provede insta-
laci odpovídajících ovladačů.
Programová rozhraní pro grafické adaptéry
Grafická rozhraní
-
31
-
Existují také knihovny, které implementují ovladače OpenGL pomocí volání vyšších nebo nižších rozhraní a
umožňují tak použití OpenGL na adaptérech, které nejsou od výrobce vybaveny podporou OpenGL. Příkladem
je produkt Scitech GL Direct, který poskytuje ovladač emulující OpenGL pro grafické akcelerátory vybavené
ovladačem Direct3D. OpenGL je i pro tyto důvody na nejlepší cestě stát se skutečným, a zatím jediným grafic-
kým standardem na všech hlavních platformách. Za tohoto stavu je proto možné, bez starostí o budoucí podporu
výrobců grafických akcelerátorů, používat OpenGL pro tvorbu rychlých a přenositelných uživatelských aplikací.
3.3.3
Stávající knihovny a nadstavby pro OpenGL
Na síti Internet jsou k dispozici některé grafické knihovny, většinou rozšiřující možnosti knihovny OpenGL.
Zaměřeny jsou především pro trojrozměrnou grafiku, například pro účely zjednodušení modelování, vytvoření
reprezentace trojrozměrných objektů s možností ukládání a nahrávání, práce s texturami, usnadnění tvorby her, a
pro účely speciálních aplikací OpenGL (CAD/CAM). Seznam těchto známých rozšíření a knihoven pro OpenGL
je k dispozici na Internetové stránce www.opengl.org .
Méně je zatím rozhraní OpenGL využíváno pro tvorbu nadstaveb a knihoven pro účel práce s dvourozměrnou
grafikou. Diplomová práce si klade za cíl vyplnit mezeru v této oblasti a pokusit se přinést 2D grafickou
knihovnu založenou na OpenGL. Tuto knihovnu jsem pojmenoval MGL.
Programová rozhraní pro grafické adaptéry
Návrh grafické knihovny MGL
-
32
-
4
Návrh grafické knihovny MGL
4.1
Zadání diplomové práce
V zadání diplomové práce bylo navrhnout knihovnu 2D grafických funkcí, která by byla využitelná v jednodu-
chých aplikacích. Při realizaci se mělo dbát na to, aby tato knihovna byla využitelná i pod Windows. Vzhledem
k současné situaci grafických rozhraní a výhod prostředků OpenGL, jsem pro vykreslování grafických objektů
mé knihovny použil prostředků OpenGL.
4.2
Současný stav 2D grafických rozhraní
Všechny platformy a operační systémy, nebo překladače různých programovacích jazyků, samozřejmě nabízejí
vlastní rozhraní umožňující použití dvourozměrné grafiky. Nevýhodou je ovšem rozdílnost nabízených funkcí.
S přechodem z jedné platformy na druhou je nutno kód realizující grafické zobrazování obvykle napsat celý
znovu. Mnohá tato rozhraní pro svou obecnost a široké možnosti použití jsou pro programátora poměrně obtížné
nejen pro naučení a ovládnutí, ale i pro použití. Toto se týká i samotné knihovny OpenGL, která nabízí prostřed-
ky pro 2D grafické operace.
Není mi známá žádná přenositelná grafická knihovna nebo nadstavba OpenGL určená výhradně pro 2D grafiku.
Je to způsobeno pravděpodobně tím, že teprve v nedávné době OpenGL přestává být bráno jako nástroj, použí-
vaný výhradně na velmi výkonných počítačích.
4.3
Účel mnou navržené knihovny a motivace vývoje
•
Zjednodušit vytváření aplikací používajících grafické výstupy
Všechny standardy grafických rozhraní sice nabízejí široké možnosti, pro jejich obecnost ale bývá jejich použí-
vání složitější. Navržená grafická knihovna by měla situaci zjednodušit a umožnit tak rychle, bez studia manuálů
vytvořit jednoduché grafické aplikace, například pro studijní účely a demonstraci algoritmů. Příkladem může být
aplikace která počítá fraktály. Vývojář této aplikace může fraktál počítat v systémové paměti a pomocí mé
knihovny MGL jej potom bez znalosti problematiky grafických rozhraní snadno a na kterékoliv platformě zobra-
zit.
•
Zachování přenositelnosti
Nespornou a velkou výhodou použití OpenGL je právě přenositelnost aplikací, bez nutnosti zasahovat do
zdrojových kódů aplikací pro zprovoznění na určitých platformách. Toto je možné vzhledem k tomu, že knihov-
na MGL vystačí s voláním OpenGL a GLUT.
Programová rozhraní pro grafické adaptéry
Návrh grafické knihovny MGL
-
33
-
•
Rozšíření možností OpenGL
Rozšíření je primárně určeno pro nejčastěji používané oblasti 2D grafiky, kterou je
•
práce s obrazovými mapami,
•
práce s fonty,
•
podpora běžných grafických formátů pro použití s OpenGL.
Tyto možnosti OpenGL pro svou obecnost nenabízí. Přesto v mnoha aplikacích jsou tyto možnosti potřeba. Vý-
vojáři jsou proto nuceni psát vlastní knihovny.
•
Výrazné usnadnění použití 2D grafiky oproti OpenGL
Pomocí volání standardních knihoven jazyka C, OpenGL, a jeho standardních nadstaveb GLU a GLUT, lze
samozřejmě určitou konečnou sekvencí příkazů dosáhnout stejných výsledků jako při použití knihovny MGL.
Toto ovšem není možné bez poměrně dobré a široké znalosti tohoto rozhraní, což není nejjednodušší záležitost.
Knihovna OpenGL (bez rozšíření GLUT a extensí) totiž obsahuje přes 250 programových funkcí (!). Situ-
aci příliš nezachraňuje ani to, že OpenGL je vzhledem k ostatním rozhraním dokumentován velmi dobře a je pro
něj k dispozici mnoho ukázkových příkladů. Naproti tomu, s použitím knihovny MGL bude možné stejné vý-
sledky dosáhnout s minimálním úsilím a počty napsaných řádek zdrojových textů, a dokonce bez samotné zna-
losti jediného příkazu OpenGL.
•
Podpora vývoje uživatelského rozhraní široké rodiny 3D grafických aplikací
Velká většina těchto aplikací vyžaduje pro určitou interakci s uživatelem, především pro tvorbu uživatelského
rozhraní, používat mnohé prvky z dvourozměrné graficky. Jsou to například texty, kurzory, ovládací prvky a
nabídky menu (2D overlays). Pro tvorbu takovýchto aplikací je nutno obvykle vytvořit vlastní doplňující pro-
gramové funkce, protože OpenGL tyto možnosti neposkytuje. Motivem mé knihovny MGL je usnadnění vývoje
těchto aplikací nabídnutím programových funkcí vykreslujících tyto prvky. Navržená knihovna bude podporovat
společné použití takovýchto aplikací a 2D grafických funkcí knihovny MGL. Přitom nebude nutné přizpůsobo-
vat zdrojové kódy takovýchto aplikací knihovně MGL.
•
Vysoký výkon
Pro vytváření obrazu nabízí OpenGL různé funkce. Tyto funkce se ovšem liší svými možnostmi a výkonem.
Různé verze OpenGL (stávající 1.0, 1.1 a 1.2) se navzájem liší svými možnostmi. Novější verze jsou zpětně plně
kompatibilní se staršími. Je tedy garantováno, že všechny příkazy OpenGL z nižších verzí budou pracovat i s
novějšími verzemi. Využitím možností nových verzí ovšem můžeme znatelně zvýšit výkon. Knihovna MGL
bude vycházet z možností jednotlivých verzí, případně i extensí knihovny OpenGL pro zajištění co nejvyš-
šího možného výkon. Knihovna MGL na konkrétním systému zjistí verzi, případně možnosti nabízené na použi-
té implementaci OpenGL. Podle toho použije co možná nejefektivnější řešení.
4.4
Typický uživatel knihovny MGL
Pro používání knihovny budou potřeba základní znalosti obecné problematiky dvourozměrné grafiky a jazyka C.
Znalost problematiky OpenGL a grafických adaptérů, především pro běžné použití knihovny MGL není nutná.
Programová rozhraní pro grafické adaptéry
Návrh grafické knihovny MGL
-
34
-
Knihovna je zaměřená na tento okruh uživatelů:
•
Programátory a uživatele, vyvíjející aplikace, které nejsou primárně založeny na grafice. Spíše potřebují
grafické výstupy pouze pro rychlou demonstraci výsledků a výstupů svých programů. Raději dávají
přednost striktnímu oddělení grafické části od svých algoritmů nebo programů a nechtějí ztrácet čas
studováním problémům grafických rozhraní, protože realizace jejich řešení neleží v oblasti grafických roz-
hraní. Příkladem jsou studenti vytvářející programy typu zobrazování funkcí, grafy. Vzhledem
k implementační nezávislosti se zde nabízí možnost vyvíjet je na více platformách najednou, například na
školním a domácím počítači.
•
Programátory uvažující o tvorbě aplikací, běžících na více platformách (například multimediální apli-
kace). Ti potřebují rychle a efektivně zajistit grafické základy své aplikace, například pro menu, aplikační
interface, animace). Nutno uznat, že takovéto aplikace zatím prakticky neexistují. S rostoucím zájmem o Li-
nux, jako platformy pro použití doma nebo v kanceláři (mnoho, dnes již kvalitního softwaru je pro tyto sys-
témy dnes nabízen zdarma), lze ale toto použití v blízké budoucnosti očekávat.
•
Programátory, kteří přecházejí z grafických prostředí nižší úrovně a knihoven pro DOS do Windows,
nebo uvažující o rychlém přechodu z jiných grafických rozhraní do prostředí OpenGL. Filozofie
knihovny MGL je právě založena na pokusu nabídnout přístup k vysokému výkonu dnešních grafických
adapterů (pomocí OpenGL) s průhledností použití jednoduchých grafických knihoven.
•
Studenty a programátory seznamující se s možnostmi OpenGL. Těmto uživatelům mohou zdrojové
kódů knihovny přinést velmi cenné zkušenosti, seznámit je s často používanými funkcemi OpenGL a pomo-
hou jim ušetřit spoustu času, který by museli věnovat implementaci vlastních podobných volání. Tato
knihovna poslouží jako alternativní úvod do OpenGL. Analýzou komentovaných zdrojových kódů, obsahu-
jících snadno pochopitelné funkce MGL, implementované pomocí funkcí OpenGL a GLUT, lze snadno po-
chopit princip práce a základní možnosti těchto skvělých knihoven.
•
Programátory vytvářející 3D aplikace a hry. Jak již bylo řečeno, většina těchto aplikací se neobejde
bez prvků 2D grafiky, především pro tvorbu uživatelského rozhraní. Dále na programátory, kterým chybí
určité možnosti OpenGL, které realizuje knihovna MGL, zejména snadnou práci s obrazovými mapami a
fonty.
Těžko lze ovšem očekávat použití této knihovny profesionálními vývojáři. Ti tvoří projekty používané rám-
cově stovkami tisíc uživatelů. Režie, investice a počty řádek zdrojových kódů pro takovéto projekty řádově ně-
kolikanásobně předčí moje úsilí věnované této práci. Tito uživatelé rovněž obvykle raději použijí vlastní řešení
na míru. Výhody, které nabízí knihovna MGL (přenositelnost, jednoduchost použití) zde není vyžadována. Navíc
očekávají zajištěnost budoucí podpory produktu.
4.5
Možnosti knihovny MGL
•
Funkce pro manipulaci s okny
Žádná dnešní aplikace se bez prostředků této práce neobejde. Proto tyto prostředky nabízí i knihovna MGL.
•
Práce s klávesnicí a myší
Programová rozhraní pro grafické adaptéry
Návrh grafické knihovny MGL
-
35
-
K dispozici jsou běžné funkce, jako je detekce stištěných kláves, čtení polohy a tlačítek myši a dále nastave-
ní vzhledu kurzoru myši na kurzory nabízené operačním systémem. Kromě toho nabízí knihovna MGL
možnost použít vlastního kurzoru, například pomocí obrazové mapy s použitím průhlednosti. To se používá
i v multimediálních aplikací a hrách.
•
Konstrukce základních grafických primitiv
Knihovna MGL podporuje kreslení bodů, úseček, trojúhelníků a obdélníků. Dále je možné použít vyplnění,
barevnou interpolaci a průhledné vrstvy pro tato primitiva.
•
Práce s obrazovými výřezy
Na tyto prvky, v oblasti 2D grafiky nejvíce používané, je kladen v této práci největší důraz. Prozkoumáním
většiny skutečných aplikací používající 2D grafiku na všech platformách zjistíme, že grafické výstupy těch-
to aplikací jsou sestaveny především z barevně vyplněných oblastí a obrazových map. Zobrazování obrazo-
vých map je v knihovně MGL realizováno mapováním textur.
•
Práce s rastrovými fonty
Tato část úzce souvisí s předchozí. Opírá se o možnosti předchozí části, vzhledem k tomu, že písmena fontů
jsou realizována pomocí obrazových map.
•
Podpora grafických formátů
OpenGL ani jeho standardní nadstavby nepodporují žádné vstupní soubory založené na grafických standar-
dech. Knihovna MGL nabízí podporu formátu .BMP, .TGA, a .SGI.
•
Volitelné zvětšení nebo zmenšení všech vykreslovaných dat
OpenGL obsahuje mnohé prostředky k zajištění zmenšení nebo zvětšení. Knihovna MGL umožňuje nadefi-
novat vlastní systém souřadnic, zlepšující snadnost implementace aplikace a přenositelnosti. Bude mít mož-
nost používat jedny souřadnice bez ohledu na velikost použitého okna. Dále je možné zvětšit nebo zmenšit
všechna vykreslená data. Knihovna také nabízí údaje o rozlišení obrazovky. Z tohoto údaje je přizpůsobit
velikost okna a nastavit systém souřadnic tak, aby okno aplikace bylo dobře viditelné na všech systémech a
platformách.
•
Přenositelnost
Knihovna používá jen standardní a přenositelné rozšíření OpenGL - knihovny GLU a GLUT. Používá jen
standardních konstrukcí a knihoven jazyka ANSI C. Pro zajištění několika specifických požadavků určitých
systémů je využito podmíněného překladu (direktiva jazyka C
#include
).
•
Přehlednost a otevřenost
Knihovna je modulární a je naprogramovaná tak, aby ji bylo možné snadno doplnit a rozšířit o uživatelské
požadavky, například o další vykreslovací funkce, možnosti apod. Rozšíření je možné přidáním samostat-
ných zdrojových souborů, s voláním OpenGL a jeho nadstaveb nebo přímým doplněním zdrojových kódů
knihovny MGL.
Programová rozhraní pro grafické adaptéry
Návrh grafické knihovny MGL
-
36
-
Aby si mohl čtenář vytvořit určitou základní představu o možnostech knihovny MGL a o odpovídajících okru-
zích příkazů OpenGL, o které se knihovna opírá, je zde následující obrázek:
Obrázek 26 –Přehled základních možností knihovny MGL
S použitím OpenGL a knihovny GLUT by byly tyto funkce zajištěny voláním následujících okruhů příkazů:
•
Vytvoření okna na pracovní ploše -
glutInit, glutGet, glutSwapBuffers,
glutInitWindowSize, glutInitWindowPosition, glutCreateWindow,
glutFullScreen, glutReshapeFunc, glutDisplayFunc, glutIdleFunc,
glutMainLoop, glutSetWindowTitle, glutReshapeWindow, glutInitDisplayMode
•
Nastavení parametrů uvnitř okna OpenGL -
glClearColor, glClearScreen, glViewport,
glClear, glFinish, glMatrixMode, glLoadIdentity, gluOrtho2D,
glPixelStorei, glPushAttrib, glPushMatrix, glPopMatrix, glPopAttrib,
glGetString
•
Body (Points), úsečky (Lines), trojúhelníky (Triangles), čtverce (Rectangles) -
glBegin, glEnd,
glVertex2i, glColor4f, glGetFloatv, glPointSize, glLineWidth, glEnable,
glDisable, glHint, glGetError
•
Vyplňování (Filling) a míchání barev (Interpolation)-
glPolygonMode, glShadeModel,
glEnable, glDisable
Programová rozhraní pro grafické adaptéry
Návrh grafické knihovny MGL
-
37
-
•
Míchání průhledných vrstev (Blending)-
glAlphaFunc, glEnable, glDisable
•
Rotace (Rotation) –
glTranslatef, glRotatef
•
Formáty obrázků (Image formats) – OpenGL nepodporuje nahrávání souborů s obrázky uložených na
disku
•
Textury (Textures) –
glTexCoord2f, glBindTexture, glGenTextures,
glDeleteTextures, glAreTexturesResident, glGenLists, glNewList,
glCallList, glEndList, glTexImage2D, gluBuild2DMipmaps, glTexParameterf,
glTexEnvf, glEnable, glDisable
•
Fonty (Fonts) –
glutBitmapCharacter
•
Práce se vstupními zařízeními (More features) –
glutSetCursor, glutGetModifiers,
glutKeyboardFunc, glutSpecialFunc, glutMouseFunc, glutPassiveMotionFunc,
glutMotionFunc, glutEntryFunc
4.6
Požadavky knihovny MGL
•
Kompilátor jazyka ANSI C pro 32-bitové aplikace. Zdrojové kódy a hlavičkové knihovny MGL jsou
zapsány v tomto jazyce. Jazyk C, vzhledem k současné situaci na trhu je jediným standardním jazykem při-
padajícím pro tvorbu přenositelných aplikací.
•
Pro překlad a vytvoření knihovny je nutné mít nainstalované hlavičkové a knihovní soubory OpenGL verze
1.1 nebo vyšší. Pro spuštění aplikací používajících MGL postačí ovladač libovolné verze OpenGL (1.0
nebo vyšší). Implementace ovladače ovšem musí být 100% kompatibilní se standardem OpenGL.
•
Nainstalované knihovny systému GLUT verze 3.7 nebo vyšší (pro platformu Windows není nutné
instalovat).
•
Pro praktické použití velmi doporučuji grafický akcelerátor s hardwarovou podporou OpenGL. Bez
tohoto vybavení dosahuje knihovna MGL, stejně jako ostatní aplikace používající OpenGL velmi nízkého
výkonu, a pro většina těchto aplikací je téměř nepoužitelná.
Programová rozhraní pro grafické adaptéry
Implementace
knihovny
-
38
-
5
Implementace knihovny MGL
Celkem jsem se rozhodl implementovat přibližně 80 funkcí knihovny MGL. Jejich seznam s programátorským
popisem uvádím v příloze Popis funkcí knihovny MGL.
5.1
Struktura knihovny
Knihovna je napsána, s ohledem na přehlednost a oddělení logicky nezávislých částí, do více modulů.
Význam jednotlivých modulů je uveden v následující tabulce.
Modul
Funkce
Errors
Zpracování a ošetření chyb
Images Načítání rastrových obrázků z disků a jejich správa
Textures
Definice, ukládání obrazů do paměti grafického adaptéru, a jejich zobrazování
Window Modul
pro
zajištění implementačně nezávislé práce s okny
Input
Modul pro zajištění implementačně nezávislých vstupů klávesnice a myši a pro zajiště-
ní implementačně nezávislého časovače
Mgl Modul
zprostředkovávající inicializaci a obsahující funkce, které nepatří do ostatních
kategorií
Memory
Modul pro zajištění alokace paměti. Od standardních funkcí jazyka C se liší tím, že
monitoruje alokovanou paměť a ošetřuje situace, kdy paměť není k dispozici.
Fonts Modul,
zajišťující nahrávání fontů z disku a práci s nimi
Draw
Modul pro vykreslování základních grafických primitiv
Tabulka 1 - Seznam modulů knihovny MGL
Vykreslování knihovny se přímo opírá o funkce OpenGL.
Moduly Window a Input se opírají o možnosti GLUT a záleží na uživateli knihovny MGL, zda je použije. Pro
čtení souborů využívá modul Images a Fonts funkce jazyka ANSI C
fopen, fread, fwrite, fseek
a
fclose
.
Programová rozhraní pro grafické adaptéry
Implementace
knihovny
-
39
-
5.2
Postup implementace knihovny s diskusí možných řešení
Po prozkoumání celé šíře problematiky OpenGL, zvážení a prozkoumání nejvýhodnějších postupů, probíhala
implementace přibližně v pořadí, v jakém je popsána v této kapitole. Ta obsahuje implementaci knihovny
s vysvětlením a diskusí jednotlivých částí.
5.2.1
Práce s okny
Knihovna MGL zajišťuje funkce pro práce v okně, celé obrazovce, inicializace displeje a pro tyto účely
GLUT používá, přičemž jsou vybrány funkce potřebné pro konkrétní potřeby knihovny. Vzhledem k požadavku
přenositelnosti zde ani žádná jiná možnost nepřipadá v úvahu. Je ovšem možné práci s okny realizovat vlast-
ním způsobem, například s pomocí jednoho z popsaných řešení (např. GLX, GLW) a využít jen vykreslova-
cích funkcí MGL.
5.2.2
Základní parametry obrazového režimu
•
Pro obrazový režim je použit režim RGB. Jedná se o standardní režim naprosto běžný pro všechny adaptéry
a aplikace používající OpenGL. Použitá barevná hloubka závisí na konkrétní platformě, obvykle na použité
barevné hloubce pracovní plochy
•
Je použita technologie dvojité obrazového paměti. Vzhledem k tomu, že pro práci s 2D grafikou není třeba
používat paměti hloubky, je paměťová režie nutná k implementaci dvojité obrazové paměti přijatelná. Bez
jejího použití by byly při změně obrazu vidět nežádoucí efekty
•
Je nastavena ortogonální projekce souřadnic OpenGL. Ten umožňuje nastavení souřadného systému tak že,
levému hornímu rohu odpovídá bod (0,0) a pravému dolnímu (zvolená délka, zvolená šířka). Zvolená délka
a šířka lze nastavit libovolně tak, aby bylo možné vykreslovat data bez ovlivnění velikostí použitého okna.
Je ale samozřejmě možné nastavit tyto souřadnice podle fyzické velikosti v bodech pracovní plochy okna.
Tento systém je pro 2D aplikací nejlepší volbou. Je doporučovaný firmami Microsoft a SGI. Je také možné
zjistit velikost pracovní plochy, a tím zajistit vhodnou odpovídající volbu velikosti okna a souřadnic.
•
Implementace vyžaduje vytvoření a vyplnění funkce, která je volána pro zajištění vykreslení obrazu a při
změně velikosti okna (změna velikosti okna je indikována pomocí proměnné
mglReshaped
).
5.2.3
Vstupy myši a klávesnice
Uživatel knihovny MGL má možnost nastavit vlastní funkce, zajišťující ošetření událostí těchto vstupních zaří-
zení (keyboard and mouse handlers). Pro vstupy klávesnice a myši je přitom použit GLUT. Opět se jedná o op-
timální řešení, vzhledem k přenositelnosti a možností registrace těchto zařízení. Standardní funkce knihovny
ANSI C totiž nabízí jen velmi základní funkce pro práci s klávesnicí. Myš není podporována vůbec. Je možné
zvolit mezi systémem nabízenými kurzory a možností definovat vlastní, například pomocí obrazové mapy. Takto
je umožněno změnit velikost, tvar, přidat vrstvu průhlednosti a další specifikace. Vstupně výstupní podsystém
knihovny MGL ovšem není třeba využít a místo toho je možné využít volání zajišťující ošetření vstupních zaří-
zení. Je možné použít plynulé stínování znaků barevnou interpolací, zadáním barev jednotlivých rohů.
Programová rozhraní pro grafické adaptéry
Implementace
knihovny
-
40
-
5.2.4
Časovač
Knihovna MGL periodicky zjišťuje systémový čas pomocí standardních funkcí jazyka C. Ten lze potom použít
v aplikacích, používající knihovnu MGL pro synchronizaci rychlosti vykreslování.
5.2.5
Konstrukce základních grafických primitiv
Konstrukce těchto primitiv je v OpenGL poměrně snadná. Podmnožina těchto možností je použita i v knihovně
MGL. Je implementováno pomocí nejzákladnějších příkazů OpenGL, na základě definice hran objektů pomocí
funkce
glVertex2i
. Dále je umožněno vykreslované objekty vybarvit jednou barvou, nebo více barvami s
použitím barevné interpolace. Vzhledem k tomu, že zaměření knihovny na 2D grafiku neočekává vykreslování
příliš složitých objektů z desítkami hran, implementace nepoužívá OpenGL extense
GL_VERTEX_ARRAY
pro
definice polí hran pro zrychlení vykreslování těchto objektů. Velkou výhodou je, že knihovna MGL pro vykres-
lování primitiv používá optimalizací pro volání funkcí OpenGL. Sleduje, jaké funkce programátor volá, pamatu-
je si aktuální nastavení OpenGL (OpenGL state) a podle toho se snaží minimalizovat volání příkazů tohoto roz-
hraní. Po přidání této vlastnosti bylo zaznamenáno značné zrychlení celé knihovny.
5.2.6
Realizace obrazových map
Obrazové mapy jsou realizovány na principu mapování textur. Všechny nové 3D akcelerátory nabízejí velmi
rychlé zpracování textur, jejich uložením do grafické paměti. Tím je velmi zredukován objem dat, vysílaných
mezi systémovou sběrnicí a grafickým adaptérem. Tento postup je výhodnější, než zapisování obrazových bodů
do přímo do obrazového rámce, který OpenGL také podporuje. Na stejné technologii je založena i knihovna
MGL. K dispozici je také možnost vybarvování obrazových map a práce s jejich průhledností.
Přestože že existují knihovny, umožňující načtení různých grafických formátů, knihovna MGL používá vlastní
řešení. Důvodem je jedna nebo více následujících nevýhod jednotlivých dostupných stávajících knihoven:
•
Knihovna podporuje jen jeden grafický formát,
•
Knihovna není dodávána se zdrojovými kódy,
•
Knihovna je zaměřena jen na jednu platformu. Tento a předcházející důvod činí obtížný požadavek přenosi-
telnosti,
•
Knihovna nepočítá s výhodami a možnostmi OpenGL a zaměřuje se proto na určitou reprezentaci grafic-
kých dat, danou souřadnicovou osou, a barevný model. OpenGL ovšem umožňuje podporu různých repre-
zentací (RGB, BGR, RGBA, BGRA) a otáčení os. Požadujeme-li maximální efektivnost, je nutné přímo již
při čtení formátu počítat nebo spolupracovat s OpenGL.
Knihovna MGL podporuje na všech platformách následující formáty dat (tím je možné například používat for-
mát BMP i na počítačích SGI):
•
Microsoft .BMP – 24-bitové barevné RGB a 8-bitové černobílé obrázky. Jde o nejpoužívanější formát na
platformě Windows. Lze využívat i na platformě Linux. Komprimované obrázky .BMP knihovna MGL ne-
podporuje.
Programová rozhraní pro grafické adaptéry
Implementace
knihovny
-
41
-
•
Targa .TGA – 8-bitové černobílé obrázky a 24-bitové RGB, 32-bitové RGBA barevné obrázky. Knihovna
je schopná ve 24-bitovém formátu grafická data i ukládat. Ta mohou být vytvořena buďto uživatelem, nebo
přečtena z obrazového rámce OpenGL. Výhodou tohoto formátu je úplná podpora všech možných barev-
ných hloubek a typů obrazů. Existuje řada programů, které jsou schopny převést jiné typy obrázků do těchto
formátů. Tento formát vznikl na platformě IBM-PC, ale je možné s ním pracovat i na platformách Unix.
V současné době jde o nejpoužívanější formát, které používají aplikace založené na OpenGL. Komprimova-
né obrázky .TGA knihovna MGL nepodporuje.
•
Silicon Graphics .SGI a .BW – obrazy s 24-bitovými RGB obrazy a 8-bitové průhledné vrstvy. Jde o nej-
častější formáty na pracovních stanicích firmy SGI.
Volitelně nabízí knihovna MGL při načítání obrazů přidat nebo odebrat vrstvu, definující průhlednost.
Díky možnostem OpenGL lze jednotlivé obrazové mapy různých barevných hloubek, v jedné aplikaci kombino-
vat. Při použití obrazů s otočenou reprezentací barev (RGB – BGR) je použita extense
GL_EXT_BGRA
na všech
platformách, kde je k dispozici. Další formáty dat je možné přidáním vlastních zdrojových souborů bez nutnosti
modifikace zdrojových kódů knihovny MGL.
Různé verze OpenGL jsou vybaveny různými prostředky pro práci s texturami. Pro zajištění maximální možné
efektivity proto MGL zkoumá verze OpenGL a vybírá nejefektivnější postup.
•
Pro verze 1.0 jsou založeny na možnosti předkompilovaných příkazů (
glCallList
v OpenGL).
•
Pro verze 1.1 a vyšší nebo při dostupnosti OpenGL extense
EXT_TEXTURED_OBJECTS
je použito efek-
tivnějšího způsobu založeného na možnosti OpenGL lépe spravovat textur, bez nutnosti jejich opětovné
konverze a vytváření které je nutné. Jde o techniku objektů textur (texture objects).
Při použití textur je knihovna schopná automaticky vytvořit mipmapy. Tuto možnost si volí uživatel knihovny
MGL před použitím každé textury.
5.2.7
Realizace fontů
OpenGL práci s fonty nepodporuje vůbec. Realizace fontů je možná vytvářením znaků pomocí bitových map,
map textur a vytváření znaků pomocí spojených čar a polygonů.
•
Nevýhodou bitových map je, že současný hardware obvykle nepodporuje jejich rychlé a efektivní použití.
Navíc u bitových mapy nelze měnit velikost, nebo provést rotace. Takto realizované fonty používá i GLUT.
Tento postup je sice velmi jednoduchý, ovšem se stávajícím hardwarem velmi neefektivní. I kdyby zobrazo-
vací hardware podporoval zpracování bitových map, což vůbec není obvyklé, je nutné bitové mapy vždy
znovu poslat po systémové sběrnici do grafického adaptéru. Rozhraní OpenGL, totiž nepodporuje, aby bito-
vé mapy byly uloženy v paměti grafického adaptéru. Realizace pak obvykle spočívá v tom, že procesor pře-
vede bitové hodnoty na barevné hodnoty RGB, a potom je pošle po systémové sběrnici do zobrazovacího
hardwaru.
Programová rozhraní pro grafické adaptéry
Implementace
knihovny
-
42
-
•
Mapování textur se hodí dobře pro vytváření textů, protože k jejich použití lze snadno použít podporu gra-
fického hardwaru. Lze využít i změnu velikosti a barev písmen, případně vypisovaný text rotovat.
•
Vektorové fonty nejsou tak rychlé, protože k jejich vytvoření je nutno použít více grafických operací, zatím-
co pro fonty založené na mapování textur stačí vykreslit jeden čtverec potažený texturou. Práce s texturami
je pro současné grafické adaptéry velmi rychlá. Fonty lze nakreslit v libovolném grafickém programu, který
pracuje s obrazovými mapami.
Knihovna MGL používá mapované textury, který je se stávajícím hardwarem efektivní, založený na mapování
textur na čtverce. Všechny znaky daného fontu jsou uloženy v jednom obrázku. Obrázek je poté uložen do lokál-
ní paměti zobrazovacího adaptéru, jako textura. Jednotlivé znaky jsou vypisovány do obrazového rámce, zobra-
zením výřezu textury. Tento postup je výrazně výhodnější a efektivnější, než samostatné textury pro každý znak.
Hardware, který mapuje textury totiž obvykle potřebuje určitý čas k přepnutí na jinou textury. Pro obrazové
mapy, obsahující znaky fontů jsou obvykle použity 8-bitové černobílé obrázky, lze ale použít i 24-bitové nebo
32-bitové barevné obrázky. Při použití 8-bitových černobílých obrázků je použit formát textur
GL_INTENSITY
, který nastavuje průhlednost a jas barevných bodů podle hodnoty 0 – 255. Hodnota průhled-
nosti a jasu je přitom pro každý bod stejná. To umožňuje, aby písmena fontu byla mimo svých okrajů průhledná.
Musí být zapnuto míchání průhledných vrstev systémem OpenGL, protože bez něho by vznikly efekty zřejmé
z následujících obrázků:
Obrázek 27 – Nežádoucí černé okraje písmen, které vznikají bez zapnutého míchání průhledných vrstev (vlevo)
Obrázek 28 –Při zapnutém míchání průhledných vrstvách je možné přirozené splynutí písmen s pozadím (vpra-
vo)
Formát textur
GL_INTENSITY
je dispozici pouze v OpenGL verze 1.1 a vyšší. Pro verzi 1.0 je proto použit
formát
GL_LUMINANCE_ALPHA
, kterým lze docílit stejného výsledku, pro textury ovšem potřebuje dvojná-
sobné množství paměti.
Programová rozhraní pro grafické adaptéry
Implementace
knihovny
-
43
-
Souřadnice jednotlivých znaků v souboru jsou uloženy v samostatném textovém souboru. Pro uložení obrazové
části jsou použity formáty souborů popsané v předchozí podkapitole. Struktura textového souboru se souřadni-
cemi znaků je následující:
•
Na prvním řádku je uloženo jméno fontu, implicitní délka a šířka znaku, a délky mezer mezi jednotlivými
znaky a řádky.
•
V dalších řádcích je pro každý znak obsažený v souboru uložena pozice X a Y odpovídající pozici znaku
v obrazové mapě, jeho délka a šířka (jsou-li tyto údaje nulové, použije se implicitní), a ASCII znak daného
znaku. Je možné místo konkrétního znaku uvést znak ‘?‘ a do závorky uvést v desítkové soustavě číslo zna-
ku, odpovídající číslu znaku v ASCII tabulce.
5.2.8
Ošetření chyb
Modul Errors obsahuje funkci
mglError
, která je volána s řetězcem popisujícím chybu, která se vyskytla.
Standardně je na konzole operačního systému vypsána chybová zpráva (na systémech Windows se objeví okno
s popisem chyby). K těmto chybám obvykle ovšem dochází ve velké většině případů špatným použitím knihov-
ny aplikačním programátorem. Je ale možné zajistit ošetření chyby vlastními prostředky. Proto lze očekávat, že
tyto změny často potřeba nebudou. Tohoto lze dosáhnout zavoláním funkce
mglSetErrorHandler
s parametrem příslušné uživatelské funkce, která provede ošetření chyby. Takto je možné změny provést bez
nutnosti zásahu do zdrojových kódů MGL.
5.2.9
Práci s vrstvami, které řeší problém překrývání grafických objektů
Pracujeme-li s 3D grafikou, problém překrývání objektů snadno vyřešíme použitím paměti hloubky. Tento po-
stup ale obvykle vyžaduje od grafického adaptéru další paměť, která by jinak mohla být použita pro jiná grafická
data (v našem případě především pro textury). Při práci s 2D grafikou postačí jednodušší metody. Stačí aby apli-
kace, používající MGL vykreslovala objekty v pořadí nejvíce vzdálených objektů k nejbližším. Tento postup je
možný vzhledem k tomu, že k vysokému výkonu běžných grafických adaptérů je možné celou grafickou scénu
vykreslovat znovu. Při použití dvojitého obrazového rámce ani jiný jednoduchý způsob řešení není možný.
5.2.10
Spolupráce s ostatními příkazy OpenGL
Pro ty, kteří chtějí doplnit možnosti knihovny MGL vlastními zobrazovacími příkazy OpenGL (například pro již
zmiňovanou 3D grafiku), je umožněno zcela oddělit volání MGL od ostatních příkazů OpenGL. To se provede
tak, že na začátku a konci bloku příkazů ve funkci zajišťující obnovu obrazu se použijí příkazy
mglBegin a
mglEnd
. Tyto příkazy ukládají aktuální charakteristiky a stavové proměnné OpenGL na zásobník a nastavují je
na hodnoty používané knihovnou MGL. Po ukončení bloku jsou původní hodnoty obnoveny. Mimo tento blok
příkazů může uživatel použít vlastních libovolných příkazů OpenGL, použít libovolných projekcí, transformací
apod. K dispozici je i velikost otevřeného okna a další charakteristiky.
Programová rozhraní pro grafické adaptéry
Instalace knihovny MGL
-
44
-
6
Instalace knihovny MGL
6.1
Obecná platforma
Pro instalaci a použití knihovny MGL na obecné platformě je třeba:
•
Nainstalovat požadované knihovny OpenGL a GLUT.
•
Zkopírovat hlavičkové soubory OpenGL a GLUT do adresáře, odkud jsou přístupné použitému překladači
jazyka C.
•
Všechny hlavičky funkcí, proměnných a definovaných typů knihovny jsou uloženy hlavičkovém v souboru
/include/mgl.h
knihovny. Tento soubor je nutné zpřístupnit pomocí standardní direktivy jazyka
C
#include <mgl.h>
. Adresář /include/ je nutné zahrnout do adresářů, které kompilátor prohledává na
výskyt hlavičkových souborů. Ty jsou obvykle uloženy v systémové proměnné
INCLUDE
.
•
Zkompilovat zdrojové soubory modulů knihovny MGL (draw.c, errors.c, fonts.c, images.c, input.c, me-
mory.c, mgl.c, textures.c a window.c). Programem pro tvorbu knihoven (na některých platformách pro-
gramem pro tvorbu archívů) na dané platformě vytvořit knihovnu obsahující všechny tyto moduly. Všechny
tyto zdrojové soubory jsou v adresáři /lib/ souborů knihovny.
•
Přeložit požadovanou aplikaci (například demonstrační aplikaci DEMO), používající knihovnu MGL.
•
Sestavovacím programem (linker) spojit vytvořenou knihovnu a aplikaci.
Všechny potřebné soubory knihovny MGL (včetně zdrojových souborů, testovacích dat a obrázků, předkompi-
lovaných knihoven a spustitelných souborů) jsou k dispozici v komprimované podobě ve formátu .zip na přilo-
žených disketách. Diskety jsou naformátované pro počítače IBM PC a kompatibilní. Obsah disket je podrobněji
popsán v kapitole Obsah přiložených disket v příloze.
6.2
Platforma Windows
Knihovna MGL byla vytvořena s použitím nástroje Microsoft Visual C++ verze 6.0. Pro tuto platformu jsou
k dispozici soubory .dsw a .dsp (Microsoft Visual C++ Workspace, Microsoft Visual C++ Project). Po otevření
souboru mgl.dsw systémem Microsoft Development Studio je možné velmi snadno přeložit, spustit a ladit
knihovnu MGL, včetně všech demonstračních programů a příkladů v kapitole Popis funkcí knihovny MGL,
přílohy. To lze provést příkazem Batch build z menu Build. Pro jiné kompilátory je nutné použít postup pro
obecnou platformu, který je popsán výše. Pro tuto platformu jsou navíc k dispozici v adresáři /bin/ předkompilo-
vané spustitelné soubory (včetně aplikace DEMO) a soubor mgl.lib, obsahující jádro knihovny. V tomto adresáři
je navíc uložen soubor glut32.dll. Díky tomu není pro tuto platformu nutné instalovat požadovanou knihovnu
GLUT.
Programová rozhraní pro grafické adaptéry
Instalace knihovny MGL
-
45
-
6.3
Platforma Linux
Pro tuto platformu je k dispozici soubor makefile, pro automatické vytvoření knihovny a aplikací ze zdrojových
souborů. Po vypsání příkazu
make
v adresáři /bin/ souborů knihovny systém vytvoří všechny demonstrační
a testovací soubory knihovny MGL. Modifikací nebo doplněním tohoto souboru lze snadno vytvářet vlastní
aplikace používající knihovnu MGL. Pro tuto platformu jsou k dispozici navíc knihovní soubor
mgl.a
a před-
kompilované spustitelné soubory (včetně testovací a demonstrační aplikace DEMO).
Programová rozhraní pro grafické adaptéry
Srovnání knihovny MGL s prostředky OpenGL
-
46
-
7
Srovnání knihovny MGL s prostředky OpenGL
Jedním z cílů pro tvorbu knihovny, jak již bylo uvedeno, bylo poskytnout programátorovi nástroj umožňující
snazší tvorbu 2D grafických objektů, než za pomoci přímého volání OpenGL. Srovnání je demonstrováno na
třech menších aplikacích. Každá z nich existuje ve dvou variantách – první je napsaná pomocí OpenGL a druhá
pomocí knihovny MGL. Všechny zdrojové soubory lze nalézt v adresáři /versus/ souborů knihovny. Kompletní
popis a vysvětlení funkcí knihovny MGL, včetně těch, které jsou použity v této kapitole, je uveden v kapitole
Popis funkcí knihovny MGL přílohy.
7.1
Srovnávací příklad alpha
Jedná se o velmi jednoduchou aplikaci, která vytvoří na pracovní ploše okno, uvnitř kterého zobrazí dva trojú-
helníky s průhlednými vrstvami. Tato aplikace byla vytvořena firmou SGI jako demonstrace ke knize [1]. Tento
případ ukazuje, že knihovna MGL umožňuje vykreslit objekty s menším úsilím. Navíc umožňuje snadněj-
ší vytvoření a inicializaci okna, než při použití okenního systému GLUT. Pro získání stejného výsledku
bylo bez použití knihovny MGL je za potřebí dvakrát více řádek kódu. Výstupy obou programů jsou uvede-
ny na následujícím obrázku. Zdrojové soubory obou verzí (alpha.c používající přímé volání OpenGL a al-
pha_m.c používající volání knihovny MGL jsou v uvedeny v příloze).
Obrázek 29 –Společný výstup programů alpha a alpha_c
Tento příklad je použit i pro demonstraci skutečnosti, že knihovna MGL, stejně jako OpenGL, není závislá
na použitém okenním systému. Místo funkcí modulu knihovny MGL Window je možné použít vlastních
funkcí okenního systému. Toto je demonstrováno na příkladu wgl.c v adresáři /wgl/, který vykresluje stejnou
scénu jako příklady alpha.c a alpha_m.c. Místo okenního systému knihovny MGL, který je založen na knihov-
ně GLUT se opírá o prostředky knihovny WGL, okenního systému na platformě Windows. Z tohoto důvodu je
Programová rozhraní pro grafické adaptéry
Srovnání knihovny MGL s prostředky OpenGL
-
47
-
samozřejmě možné jej zkompilovat a spustit pouze na platformě Microsoft Windows. Tento příklad je uveden
v příloze.
7.2
Srovnávací příklad checker
Tento příklad srovnává knihovny OpenGL a MGL vzhledem ke způsobu práce s texturami. Práce s texturami
patří k největšímu přínosu knihovny MGL. Ta, na rozdíl od OpenGL, podporuje nahrávání obrazových
map pro textury z disku. Bez jejího použití je nucen programátor nahrát textury do paměti vlastními
prostředky. Navíc knihovna MGL pro práci s texturami použije nejefektivnější metody, detekcí použité verze
OpenGL. I program checker.c sloužil jako další demonstrační program pro knihu [1]. Modifikací vznikl soubor
checkr_m.c používající funkce knihovny MGL a přímé volání OpenGL. Narozdíl od původního souboru chec-
ker.c není textura vytvářena pomocí cyklu, ale je nahrána ze souboru chess.tga. Textura v pravé části okna ne-
byla vytvořena voláním MGL ale přímým voláním OpenGL, vzhledem k tomu že MGL umožňuje vytváření
pouze dvourozměrných objektů. Tento příklad tedy i demonstruje velkou výhodu knihovny MGL, kterou je
možnost pro vytváření obrazu použít nejen volání jejich funkcí, ale i přímého volání OpenGL. Výstup
obou programů je na následujícím obrázku. S použitím knihovny MGL bylo možno zapsat příklad opět
s polovičním počtem řádků kódu.
Obrázek 30 – Společný výstup programů checker.c a checkr_m.c
7.3
Srovnávací příklad tunnel
Jako součást ukázkových příkladů ke knihovně GLUT jsou demonstrační programy, které napsal italský
programátor David Bucciarelli (jeho email je tech.hmw@plus.it). Jeden z nich, program tunnel.c simuluje pohyb
v tunelu. Pro textové výstupy (nápověda, výpis počtu rámců za sekundu) program používá bitové fonty nabízené
knihovnou GLUT. Pro účely demonstrace možností knihovny MGL jsem zdrojový kód rozšířil o volání funkcí
MGL a nahradil vypisování fontů pomocí fontů založených mapování textur knihovny MGL. Voláním funkcí
Programová rozhraní pro grafické adaptéry
Srovnání knihovny MGL s prostředky OpenGL
-
48
-
knihovny MGL místo funkcí GLUT došlo k výraznému urychlení celé aplikace, kdy počet rámců vykres-
lených za sekundu na grafických adaptérech s hardwarovou akcelerací OpenGL (při zapnuté nápovědě)
stoupnul na více než dvojnásobek. Použité volání příkazů knihovny MGL pro potřebné vykreslení jsou
srovnatelné složitosti jako prostředky knihovny GLUT. Navíc při použití fontů knihovny MGL lze libovolně
měnit velikost textových výstupů nebo měnit jejich barvu (s využitím barevné interpolace). Zjednodušil jsem i
způsob nahrávání textur podlahy a zdí scény, které byly v původní verzi řešeny voláním samotného modulu.
Původní zdrojový kód je uložen v souboru tunnel.c
.
Modifikovaná verze využívající knihovnu MGL je
v souboru tunnel_m.c. Tento příklad opět názorně demonstruje jednu z možností knihovny MGL: snadné
rozšíření 3D aplikací o jednoduché uživatelské rozhraní založené na 2D prvcích, se zachováním vysokého
výkonu takovýchto aplikací). Fragmenty obou kódů jsou opět uvedeny v příloze. Obrazovky vytvořené oběma
kódy jsou pro srovnání zobrazeny na následujících obrázcích.
Obrázek 31 – Nápověda aplikace tunnel_m vykreslená pomocí fontů založených bitových mapách
Programová rozhraní pro grafické adaptéry
Srovnání knihovny MGL s prostředky OpenGL
-
49
-
Obrázek 32 – Nápověda aplikace tunnel_m vykreslená pomocí fontů založených na mapování textur knihovny
MGL
Programová rozhraní pro grafické adaptéry
Testování
navržené
knihovny
-
50
-
8
Testování navržené knihovny
8.1
Metodika testování
Testování je založeno na rozsáhlé demonstrační a testovací aplikaci (DEMO). Její jednotlivé části jsou zaměřené
vždy na určitou podmnožinu funkcí, které knihovna MGL nabízí. Tyto části odpovídají samostatným zdrojovým
kódům zapsaném v jazyce C. Demo se snaží funkce otestovat ve všech možných variantách, s různými typy
vstupních dat a souřadnic. Jiný efektivnější způsob testování v tomto případě těžko připadá v úvahu. Knihovna
MGL po každém provedeném příkazu OpenGL testuje chybový stav OpenGL a tak se snaží omezit nekorektní
použití tohoto rozhraní. Vzhledem k tomu, že knihovna se silně opírá o prostředky knihoven OpenGL a GLUT,
rizika chyb nejsou kritická. Navíc byly chyby obvykle vizuálně dobře zjistitelné. Rozsah této testovací aplikace
je přibližně 2700 řádek kódu. Samotné jádro knihovny je přitom zapsáno přibližně v 4400 řádcích kódu. Zdrojo-
vé kódy této aplikace jsou uloženy v adresáři /demo/.
Aplikace DEMO demonstruje a testuje úplný okruh funkcí knihovny MGL:
•
Vytváření oken, změny jeho velikosti, nastavení obsluhy funkce vykreslující obrazovku, práce s časovačem,
výpis rychlosti v rámcích za sekundu. Nabízí možnost uložit obsah okna na disk do formátu obrázku TGA.
Jde o základ celé aplikace, spouštějící další testy (zdrojový kód této části je uložen v souboru de-
mo/demo.c).
•
Detekce kláves, událostí myši, kurzorů myši a dalších (soubor demo/config.c). Ukázka jedné z obrazovek
aplikace DEMO, která umožňuje testy provádět, je zobrazena na následujícím obrázku.
•
Testy vykreslování všech grafických primitiv knihovny MGL a načítání obrazových map a fontů z disku
(všech formátů a typů) a jejich vykreslování, s volitelnou barevnou interpolací a průsvitností. (soubor de-
mo/tests.c)
•
Demonstrace a testy použití různých režimů pro změnu velikosti textur (nejbližší soused, mipmapping, bili-
neární a trilineární filtrování (soubor demo/mipmap.c)
•
Několik různých jednoduchých příkladů, s nimiž jsem vykreslil některé obrázky této diplomové práce (sou-
bor demo/figures.c)
Testovací aplikaci DEMO je možné spustit se dvěma parametry, délkou a šířkou, které nastavují velikost okna.
Pokud nejsou zadány, je velikost okna nastavena na velikost 800 x 600.
Podrobnější informace je možno získat v nápovědě aplikace DEMO po jejím spuštění, která komentuje všechny
prováděné testy. Tu lze získat kdykoliv stištěním klávesy F1. Autor velmi doporučuje tuto aplikaci vyzkoušet,
protože umožňuje snadno získat představu o možnostech a knihovny MGL, lépe než dlouhé popisy. Apli-
kace také měří výkon knihovny výpisem změřených počtů obrazových rámců vypočtených za sekundu.
Programová rozhraní pro grafické adaptéry
Testování
navržené
knihovny
-
51
-
Ten se na počítačích vybavených běžným 3D akcelerátorem i na nejsložitějších obrazovkách pohybuje
rámcově v desítkách za sekundu. Tyto počty jsou srovnatelné s rychlostmi jiných aplikací založených na
OpenGL a vypovídají o efektivní implementaci knihovny MGL.
Obrázek 33 – Jedna z obrazovek testovací aplikace DEMO, umožňující otestovat okruh funkcí knihovny MGL,
umožňující práci se vstupními zařízeními. I tato obrazovka, včetně prvků jednoduchého uživatelského rozhraní,
byla vykreslena pomocí knihovny MGL.
Knihovna byla také odzkoušena implementováním menších demonstračních programů. Ty slouží pro ilustraci
podkapitoly Popis funkcí knihovny MGL, uvedené v příloze. Dále byla odzkoušena programy sloužící pro její
srovnání s OpenGL, uvedené kapitole Srovnání knihovny MGL s prostředky OpenGL. Celkem byla knihovna
odzkoušena na 15 aplikacích o celkovém rozsahu přibližně 5500 řádek kódu. Také většina obrázků v této
knize byla vytvořena voláním funkcí knihovny MGL. Množství zdrojových kódů, vytvořených pro testování
odpovídají rozsahu knihovny. Obdobně odpovídá i doba vytváření knihovny času, kterým byla knihovna podro-
bována testům a dolaďování. Testování aplikace umožnilo nejen detekci a následné odstranění chyb, ale i přidání
některých dalších užitečných možností a rysů.
Programová rozhraní pro grafické adaptéry
Testování
navržené
knihovny
-
52
-
8.2
Lidé, kteří prováděli testování
Kromě autora práce, byla knihovnu testovali studenti Emil Aubrecht (jeho email je aubrece@cslab.felk.cvut.cz)
a Davidem Vilímek (jeho email je d.vilimek@sh.cvut.cz). Oba studenti se testování zúčastnili v rámci seminár-
ních prácí předmětu Periferní zařízení (36PZ, vyučovaný na katedře počítačů), vedeném docentem Šnorkem,
který je současně vedoucím práce. Emil Aubrecht navíc v prostředí Borland C++ Builder 3.0 v jazyce ANSI C++
vytvořil jednoduchý editor MGLDRAW, umožňující kreslení grafických primitiv pomocí volání knihovny
MGL. Editor je navíc schopen nakreslená primitiva přímo exportovat do příkazů jazyka C volající funkce
knihovny MGL. Motivem je usnadnění vytváření grafických aplikací používajících MGL. Pomocí tohoto editoru
byla vytvořeny některé části úvodní obrazovky aplikace DEMO (viz Obrázek 26). Zdrojové kódy jeho editoru
jsou k dispozici v adresáři /mgldraw/ knihovny. Hlavním cílem úsilí při vyvíjení tohoto editoru bylo ověřit, zda
knihovna MGL je dostatečně dobře dokumentovaná, přehledná a bez chyb, tak, že ji mohou používat bez hlub-
ších znalostí i problémů ostatní programátoři. Oběma studentům děkuji.
Obrázek 34 – Okno grafického editoru MGLDraw
Programová rozhraní pro grafické adaptéry
Testování
navržené
knihovny
-
53
-
8.3
Seznam vybavení a platforem, na kterých byly prováděny testy
Pro zajištění a ověření maximální spolehlivosti a funkčnosti vyvíjené knihovny byly testy provedeny na
následujícím vybavení a platformách (tam kde není uvedeno, kdo testování provedl, testoval autor).
1.
Microsoft Windows 95, softwarová implementace OpenGL verze 1.2 od firmy Microsoft
2.
Microsoft Windows 98, softwarová implementace OpenGL verze 1.1 od firmy SGI (Silicon Graphics
OpenGL for Windows)
3.
Microsoft Windows 98, hardwarová implementace OpenGL verze 1.1 grafického akcelerátoru S3 Savage4 s
8 MB grafické paměti.
4.
Microsoft Windows 98, hardwarová implementace OpenGL verze 1.1 grafického akcelerátoru nVidia Riva
TNT2 s 32 MB grafické paměti (testoval David Vilímek).
5.
Microsoft Windows 98, hardwarová implementace OpenGL verze 1.1 s grafickým akcelerátorem Riva 128 s
8 MB grafické paměti (testoval Emil Aubrecht).
6.
Microsoft Windows 98, implementace emulující OpenGL voláním funkcí rozhraní Direct3D od firmy Alt-
Software, vyzkoušené na grafickém akcelerátoru S3 Savage4 s 8 MB paměti.
7.
Microsoft Windows 98, implementace Scitech GL Direct 1.0 emulující OpenGL voláním funkcí rozhraní
Direct3D od firmy Scitech Software, vyzkoušené na grafickém akcelerátoru S3 Savage4 s 8 MB paměti.
8.
Microsoft Windows 98, softwarová implementace MESA verze 1.2 (testoval Marek Gayer a David Vilímek)
9.
Microsoft Windows 98, hardwarová implementace OpenGL verze 1.1 s přídavným grafickým akcelerátorem
Voodoo Graphics se 4 MB grafické paměti (testoval Emil Aubrecht).
10.
Microsoft Windows NT 4.0, hardwarová implementace OpenGL verze 1.1 grafického akcelerátoru Matrox
Millenium G400 s 8 MB grafické paměti. (jednalo se o počítače v Modré učebně katedry počítačů).
11.
Microsoft Windows NT 4.0, softwarová implementace OpenGL verze 1.1 firmy Microsoft
12.
Microsoft Windows NT 4.0 – hardwarová implementace ATI Rage Pro s 8 MB paměti.
13.
WinLinux 2000, softwarová implementace OpenGL verze 1.2 MESA
14.
Red Hat Linux 6.0, hardwarová implementace OpenGL verze 1.2 grafického akcelerátoru Matrox Milleni-
um (Utah GLX) s 8 MB paměti (jednalo se o počítače v Modré učebně katedry počítačů).
Při testování a následném odlaďování se na některých platformách nepodařilo vyřešit určité problémy.
Vzhledem k tomu, že se vyskytovaly pouze na jednotlivých platformách, kde byly zjištěny, jsou potíže
zřejmě způsobeny nekompatibilitou stávajících ovladačů, nikoli chybnou implementací knihovny MGL.
Problémy se vyskytly v těchto případech:
•
Platforma 3 – nové ovladače OpenGL Performance ICD 1.00.18 beta mají potíže při používání knihovny
GLUT. Potíže se objevují i v jiných aplikacích OpenGL. Je nutné použít oficiální starší ovladače 8.10.23.
Nabízejí sice menší výkon, ale zato jsou spolehlivé.
•
Platforma 6 a 7 - na grafickém akcelerátoru S3 Savage4 tyto implementace nepodporují standardní formát
textur
GL_LUMINANCE
a
GL_INTENSITY
. I tento problém se vyskytuje také v ostatních aplikacích.
•
Platforma 12 - občas se zde setkáváme s nesprávně obarvenými grafickými objekty a texturami. Použitá
implementace zřejmě není 100% kompatibilní.
Programová rozhraní pro grafické adaptéry
Testování
navržené
knihovny
-
54
-
•
Platforma 14 - náhodné zhroucení aplikace DEMO při změně velikostí oken. Přitom dojde k zhroucení celé-
ho prostředí X-Window s nutností se znovu přihlásit do systému. Problémy jsou zřejmě způsobené nekom-
patibilitou ovladačů s okenním systémem OpenGL GLUT. Zde bych doporučil vyzkoušet nové ovladače.
8.4
Výsledky testování
Mnou provedené testy i výsledky testů mých kolegů potvrdily funkčnost a použitelnost vyvinuté knihovny
v plné šiří. Díky široké bázi implementací OpenGL, na kterých byla knihovna odlaďována a odzkoušena, je
velmi malá pravděpodobnost výskytu vážných chyb. Testování a ladění navíc přispělo k optimálnímu doladění
výkonu. Testování nebylo omezeno jen na vyzkoušení jedné aplikace, ale všech příkladů dodávaných
s knihovnou MGL. Všechny zmiňované aplikace napsané pro testování a demonstraci (včetně grafického editoru
MGLDRAW) byly úspěšně přeloženy a odzkoušeny pod operačními systémy Windows i Linux. Tím bylo ově-
řeno, že knihovna není závislá na použitém překladači jazyka C.
Vzhledem k výše popsaným problémům je ovšem nutné pro stabilní a bezchybný provoz knihovny MGL použít
100% kompatibilní ovladače OpenGL.
Programová rozhraní pro grafické adaptéry
Stav implementace
-
55
-
9
Stav implementace knihovny MGL
Přes časovou náročnost testování se podařilo realizovat naplánované možnosti knihovny MGL, popsané
v kapitole Implementace knihovny, v plném rozsahu. Knihovna je odladěná a odzkoušená na řadě systémů
s různými ovladači OpenGL. Uživatelé knihovny nejsou nuceni knihovnu rozšířit přímou modifikací jejích zdro-
jových kódů. Místo toho mohou doplnit vlastní funkce přidáním samostatných zdrojových kódů nebo programo-
vých knihoven. Rozšíření mohou být založena nejen na příkazech knihovny MGL, ale i na přímém volání
OpenGL.
Programová rozhraní pro grafické adaptéry
Závěr
-
56
-
10
Závěr
První částí práce bylo vytvořit rešerši moderních grafických adaptérů a jejich rozhraní. Tento cíl byl splněn vy-
tvořením zhruba 25 stránkové rešerše uspokojivě pokrývající danou tématiku.
Druhou částí práce bylo vytvořit jednoduchou grafickou knihovnu 2D grafických funkcí. Výsledkem této práce
je přenositelná knihovna MGL založená na OpenGL. Shrňme si nyní stručně její nejvýraznější výhody a přínos
výsledků, které nabízí její konečná verze:
•
Velmi snadná tvorba aplikací založených na nejčastěji používaných prvcích dvourozměrné grafiky,
zejména těch, které jsou založeny na obrazových mapách a fontech. Tvorba 2D aplikací je výrazně
snazší než při přímém použití OpenGL.
•
Možnost doplnění funkcí navržené knihovny 2D/3D funkcemi OpenGL nebo vlastními grafickými
funkcemi. Možnost doplnění již hotových aplikací založených na OpenGL o prostředky knihovny
MGL (například o uživatelské rozhraní).
•
Snadná přenositelnost navržené knihovny na širokou bázi platforem díky použití OpenGL a jazyka
ANSI C.
•
Stejně jako OpenGL není knihovna MGL závislá na konkrétním, platformově závislém prostředku
pro práci s okny. Standardně se opírá o prostředky systému GLUT, ale je možné použít i jiný systém.
•
Knihovna byla vyvinuta s použitím nejpoužívanějšího vývojového nástroje na nejrozšířenější plat-
formě - v moderním prostředí Microsoft Visual C++ 6.0 pod Windows 9x.
•
Optimalizovaný výkon díky optimálnímu využití prostředků nabízených různými verzemi OpenGL.
Na počítačích vybavených 3D akcelerátorem se při běžných aplikacích rychlost zobrazování pohybuje
řádově v desítkách počtů rámců za sekundu. Výkon tak při srovnání s jinými běžnými aplikacemi za-
loženými na OpenGL vypovídá o optimální implementaci.
•
Spolehlivost a stabilita knihovny díky testování několika aplikací, které využívají její možnosti, na
řadě počítačů s různými ovladači OpenGL. Knihovna byla odladěna a odzkoušena na platformách
Windows 9x/NT a Linux.
•
K dispozici je řada ukázkových příkladů, které demonstrující její možnosti, ilustrují použití jejích
funkcí a umožňují její srovnání s prostředky OpenGL.
Kromě autora práce provedli testování dva studenti předmětu Periferní zařízení, kteří potvrdili použitelnost,
funkčnost a spolehlivost knihovny. Jeden z nich navíc vyvinul jednoduchý grafický editor využívající pro zob-
razování vykreslených objektů knihovny MGL. Tento editor je vedlejším produktem této diplomové práce.
Úspěšným návrhem, implementací a testováním knihovny byla i druhá část zadání splněna.
Programová rozhraní pro grafické adaptéry
Závěr
-
57
-
Dokončením a obhajobou diplomové práce na Katedře počítačů Elektrotechnické fakulty ČVUT knihovna MGL
nekončí. Autor knihovny plánuje další vylepšování a optimalizaci produktu, a vytvoření anglické dokumentace s
popisem funkcí knihovny. Poté bude knihovna uvolněna, aby zdarma sloužila programátorům OpenGL na celém
světě.
Práce ukázala použitelnost rozhraní OpenGL nejen jako ideálního nástroje pro aplikace založené na 3D grafice,
ale i jako vhodný nástroj pro tvorbu 2D aplikací nebo uživatelského rozhraní 2D/3D aplikací. Pro tyto účely je
pro programátora vhodné vytvořit určitou knihovnu funkcí. Přitom vhodnou volbou je výsledek této diplomové
práce, knihovna MGL. Zejména proto, že obdobný produkt, využívající OpenGL jako primárního prostředku pro
realizaci 2D knihovny grafických funkcí, zatím nebyl k dispozici.
Programová rozhraní pro grafické adaptéry
Použitá
literatura a zdroje
-
58
-
11
Použitá literatura a zdroje
11.1
Literatura
[1]
Mason, W. - OpenGL Architectural Review Board – Jackie, N. – Davis, T. – Shreiner, D.: The OpenGL
Programming Guide. Addison-Wesley, 1998.
[2]
Wright, R. - Sweet, M.: OpenGL SuperBible 1
st
Edition. Waite Group Press, 1997.
http://www.itknowledge.com/reference/archive/1571690735/ewtoc.html
[3]
Sochor, J. – Žára, J. – Beneš, B.: Algoritmy počítačové grafiky. ČVUT Praha, 1996.
[4]
Hudec B.: Základy počítačové grafiky. ČVUT Praha, 1993.
[5]
Šnorek M.: Periferní zařízení. ČVUT Praha, 1997.
[6]
Šnorek M.: Technické vybavení pro počítačovou grafiku. ČVUT Praha, 1997.
[7]
Vrátil Z.: Grafický subsystém PC. GETHON audio and computer, 1993.
[8]
Limpouch A.: X Window System Programování aplikací. Grada, 1993.
[9]
Richta, K. – Brůha, I.: Programovací jazyk C. ČVUT Praha, 1991.
11.2
Elektronické dokumenty
Zde vždy uvádím název dokumentu nebo článku. Pokud je známý autor (nebo alespoň firma) který článek vytvo-
řil, je uveden za pomlčkou. U každého článku nebo dokumentu je uvedena adresa sítě Internet, kde je možné
článek získat.
11.2.1
Nápovědy a dokumentace programových nástrojů
[10]
Nápověda systému Microsoft Visual C++ 6.0 pro OpenGL – Microsoft
ftp://ftp.microsoft.com/developr/platformsdk/jan2000/common/help/opengl.chm
ftp://ftp.microsoft.com/developr/platformsdk/jan2000/common/help/opengl.chi
[11]
Nápověda systému Microsoft Visual C++ 6.0 pro DirectX - DirectX 7.0 Programmer's Reference –
Microsoft
ftp://ftp.microsoft.com/developr/platformsdk/jan2000/common/help/dxfound.chm
ftp://ftp.microsoft.com/developr/platformsdk/jan2000/common/help/dxfound.chi
[12]
Introducing DirectX Foundation – dokumentace SDK (Software Development Kit) DirectX 7.0 – Micro-
soft
[13]
ftp://ftp.lib.uni.lodz.pl/pub/win/system/dx7sdk-700.1.exe
Direct3D Immediate Mode – dokumentace k SDK DirectX 7.0 – Microsoft
[14]
ftp://ftp.lib.uni.lodz.pl/pub/win/system/dx7sdk-700.1.exe
Programová rozhraní pro grafické adaptéry
Použitá
literatura a zdroje
-
59
-
[15]
DirectDraw – dokumentace k SDK DirectX 7.0 – Microsoft
ftp://ftp.lib.uni.lodz.pl/pub/win/system/dx7sdk-700.1.exe
11.2.2
Články a dokumenty ze sítě Internet
[16]
OpenGL - The Industry’s Foundation for High Performance Graphics – SGI
http://www.opengl.org/Downloads/OpenGL_Datasheet.pdf
[17]
The Design of the OpenGL Graphics Interface - Mark Segal, Kurt Akeley
http://trant.sgi.com/opengl/docs/white_papers/opengl/index.html
[18]
The OpenGL Graphics Interface - Mark Segal, Kurt Akeley
http://trant.sgi.com/opengl/docs/white_papers/oglGraphSys/opengl.html
[19]
The OpenGL Graphics System: A Specification (Version 1.1) - Mark Segal, Kurt Akeley
http://trant.sgi.com/opengl/docs/Specs/glspec1.1/glspec.html
[20]
The OpenGL Graphics System: A Specification (Version 1.2.1) - Mark Segal Kurt Akeley
ftp://sgigate.sgi.com/pub/opengl/doc/opengl1.2/opengl1.2.1.pdf
[21]
The OpenGL Graphics System Utility Library (Version 1.3) - Norman Chin Chris Frazier Paul Ho
Zicheng Liu Kevin P. Smith
ftp://sgigate.sgi.com/pub/opengl/doc/opengl1.2/glu1.3.pdf
[22]
Manuálové stránky OpenGL – Digital
http://www.eecs.tulane.edu/www/graphics/doc/OpenGL-Man-Pages/opengl.zip
[23]
The OpenGL Utility Toolkit (GLUT) Programming Interface API Version 3 - Mark J. Kilgard
http://reality.sgi.com/opengl/spec3/spec3.html
http://reality.sgi.com/mjk/glut3/glut-3.spec.pdf
[24]
Using OpenGL to Create 2D and 3D Graphics - Scientific Visualization Software
http://www.oac.ucla.edu/rts/scivis/software/opengl.htm
[25]
OpenGL Overviews v časopise LinuxFocus Magazine
http://mercury.chem.pitt.edu/~angel/LinuxFocus/English/January1998/index.html
http://mercury.chem.pitt.edu/~angel/LinuxFocus/English/March1998/index.html
http://mercury.chem.pitt.edu/~angel/LinuxFocus/English/May1998/index.html
Programová rozhraní pro grafické adaptéry
Použitá
literatura a zdroje
-
60
-
[26]
OpenGL and Window System Integration - OpenGL Performance Optimization
http://www.mesa3d.org/brianp/sig97/perfopt.htm
[27]
Guide to OpenGL on Windows - Silicon Graphics
http://trant.sgi.com/opengl/docs/OGL_userguide/OpenGLonWin-1.html
[28]
OpenGL ICDs, mini drivers, standalone drivers - Brian Hook
http://www.opengl.org/Products/DriverTypes.html
[29]
The Dark Side of Win32 OpenGL or Understanding the MiniGL – Robert L. Santa
http://www.gamedev.net/opengl/rls_minigl.html
[30]
All about OpenGL Extensions - Mark J. Kilgard
http://www.opengl.org/News/Special/OGLextensions/OGLextensions.html
[31]
Using OpenGL Extensions - Brian Paul
http://www.mesa3d.org/brianp/sig97/exten.htm
[32]
NVIDIA OpenGL Extension Specifications - NVIDIA Corporation
http://www.nvidia.com/Marketing/Developer/swdevpublicpages.nsf/4a87ff3bf2c03cc38525646f0072ffa9/
843ff75cd06d2a978825678500795440/$FILE/nvOpenGLspecs.pdf
[33]
Avoiding 16 Common OpenGL Pitfalls – Mark J. Kilgard
http://www.opengl.org/Coding/KilgardTechniques/oglpitfall/oglpitfall.html
[34]
Multipipe Direct Rendering Infrastructure (DRI) Q & A - Frank LaMonica
http://www.opengl.org/News/Special/DRI.html
[35]
Jemný úvod do OpenGL – Tomáš Holub ZČU Plzeň
http://herakles.zcu.cz/local/Jemny_Uvod_do_OpenGL.ps
[36]
Slidy pro výuku OpenGL v předmětu Grafické systémy na počítačích Silicon Graphics (36GSP) na
Katedře počítačů - Bedřich Beneš
benes@sun.felk.cvut.cz
[37]
Slides on Advanced Techniques in OpenGL: Blending, antialiasing, fog, bitmaps, fonts, images, texture
mapping, and the framebuffer - Dr. Jim Chen's
http://www.site.gmu.edu/~jchen6/CS652/CS652_8_15.ps
Programová rozhraní pro grafické adaptéry
Použitá
literatura a zdroje
-
61
-
[38]
OpenGL Game Development Mailing List: Frequently Asked Questions
http://www.3dgamedev.com/resources/openglfaq.txt
[39]
Microsoft DirectX Overview – Microsoft
http://msdn.microsoft.com/library/backgrnd/html/directxovrvw.htm
[40]
Průvodce programováním DirectDraw a Direct3D – Zbyšek Martoch. Jde o český překlad anglického
originálu od Briana Hooka
http://www.stud.fee.vutbr.cz/~xmarto00/PpDD.htm
[41]
Creating Reflections and Shadows using Stencil Buffer – Mark J. Kilgard
http://www.opengl.org/News/Special/StencilTalk/index.htm
[42]
Improving Shadows and Reflections via the Stencil Buffer - Mark J. Kilgard
http://www.nvidia.com/Marketing/Developer/swdevpublicpages.nsf/4a87ff3bf2c03cc38525646f0072ffa9/
843ff75cd06d2a978825678500795440/$FILE/stencil.pdf
[43]
Orthogonal Illumination Maps - Cass Everitt
http://www.opengl.org/News/Special/oim/Orth.html
[44]
Smooth Normal Generation with Preservation of Edges - Nate Robins
http://www.xmission.com/~nate/smooth.html
[45]
T-Buffer od 3Dfx – Brko, jaydee.cz
http://www.jaydee.cz/reviews/t-buffer/default.htm
[46]
Texture Mapping as a Fundamental Drawing Primitive – Mark J. Kilgard, Paul Haeberly
http://trant.sgi.com/opengl/docs/white_papers/texmap.ps
[47]
Surface Simplification: How to Perform Real Time Bumpmapping using OpenGL - Roberto Scopigno
http://vcg.iei.pi.cnr.it/bumpmapping.html
[48]
Matrox G400 – Enviroment Mapped Bumpmapping – Matrox
http://www.matrox.com/mga/press_room/tech_infos/media/pdf/bumpmap.pdf
[49]
Matrox G400 – 256-bit DualBus Architecture – Matrox
http://www.matrox.com/mga/press_room/tech_infos/media/pdf/dualbus.pdf
[50]
Matrox G400 – DualHead Architecture – Matrox
http://www.matrox.com/mga/press_room/tech_infos/media/pdf/dualhead.pdf
Programová rozhraní pro grafické adaptéry
Použitá
literatura a zdroje
-
62
-
[51]
Matrox Millennium G400 Series Reviewer’s Guide – Matrox
http://www.matrox.com/mga/press_room/tech_infos/media/pdf/Reviewer's_Guide.pdf
[52]
Matrox G400 Stencil Buffering – Matrox
http://www.matrox.com/mga/press_room/tech_infos/media/pdf/stencil.pdf
[53]
3D Benchmark Testing - How to get the most out of your results – Matrox
http://www.matrox.com/mga/press_room/tech_infos/media/pdf/3d.pdf
[54]
Trilinear Filtering: A Better Way to Texture 3D Objects – S3
http://www.s3.com/savage3d/3linear.htm
[55]
S3TC ™ DirectX 6.0 Standard Texture Compression – S3
http://www.s3.com/savage3d/s3tc.htm
[56]
S3’s Transform and Lighting Engine (S3TL™) – S3
http://www.s3.com/savage2000/tnlwhte.pdf
[57]
DuoView and Multiple Display Use - Solving today display Demands – S3
http://www.s3.com/tech/duovwwp.htm
[58]
Intel AGP Tutorial – Intel
http://developer.intel.com/technology/agp/tutorial/index.htm
[59]
Intel740™ Graphics Accelerator - Software Developer’s Manual – Intel
http://developer.intel.com/design/graphics/datashts/index.htm
[60]
PC Game Programmers‘s Encyklopedia - Mark Feldman
ftp://teeri.oulu.fi/pub/msdos/programming/gpe/pcgpe.zip
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
63
-
12
Doporučené stránky sítě Internet
12.1.1
Stránky zaměřené na rozhraní OpenGL
www.opengl.org – oficiální domovská stránka OpenGL, obsahuje nejkompletnější odkazy na zdroje dalších
informací o OpenGL. Domnívám se, že na této stránce by měl začít každý, koho problematika OpenGL zajímá.
Na této adrese lze nalézt:
•
denní novinky a zprávy ze světa OpenGL,
•
seznam aplikací využívajících OpenGL a odkazy na jejich stránky,
•
seznam výrobců grafických akcelerátorů podporujících OpenGL,
•
odkazy pro vývojáře na on-line dokumentaci, kurzy (tutorials), a programovací techniky OpenGL,
•
seznam tištěných knih o OpenGL,
•
diskusní fóra OpenGL,
http://www.sgi.com/software/opengl/ - informace a odkazy na dokumentaci k produktu OpenGL od jeho tvůrce,
firmy SGI
http://trant.sgi.com/opengl/ - tato stránka obsahuje nejdůležitější dokumentaci a příklady k OpenGL od firmy
SGI
http://reality.sgi.com/mjk/glut3/glut3.html –stránka se všemi informacemi a možností stažení knihovny GLUT.
Součástí knihovny GLUT je i velmi rozsáhlá sbírka ukázkových příkladů OpenGL.
12.1.2
Kurzy a ukázkové příklady OpenGL (OpenGL tutorials)
Ukázkové příklady, demonstrující různé funkce OpenGL, které byly vytvořeny v rámci předmětu Základy počí-
tačové grafiky na ZČU v Plzni
http://herakles.zcu.cz/local/zpg.html
Nehe’s OpenGL Tutorial – velmi dobré příklady OpenGL pro začátečníky i pokročilé. Součástí všech příkladů je
podrobný popis a vysvětlení.
http://nehe.gamedev.net/
GlGameDev () – stránka s ukázkovými příklady a technikami pro tvorbu zejména počítačových her s využitím
OpenGL od Joea Zimmermana
http://www.velocity.net/~waz/glgamedev/
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
64
-
Personal OpenGL Tutor P.O.T pro Unix - Computational Geometry and Computer Graphics Laboratory De-
partment of Electrical Engineering and Computer Science University of Wisconsin-Milwaukee
http://www.cs.uwm.edu/~grafix1/
Opengl Tutorials - Nicole Deflaux Terry
http://www.eecs.tulane.edu/Terry/OpenGL/Introduction.html
Druid‘s OpenGL Tutorials
http://www.gamedev.net/opengl/index.html
Nate Robins OpenGL Page
http://www.xmission.com/~nate/tutors.html
Nate Miller Programming Page
http://nate.scuzzy.net/
Mahesh Venkitachalam's OpenGL Web Page
http://home.att.net/~bighesh/ogl.html
Computer Science Courses – Katedra počítačové grafiky na univerzitě v Torontu
http://www.dgp.toronto.edu/people/van/courses/csc418/class/
12.1.3
Výrobci grafických akcelerátorů
www.3dfx.com – firma 3Dfx
www.3dlabs.com – firma 3DLabs
www.atitech.com - firma ATI
www.matrox.com - firma Matrox
www.nvidia.com - firma NVidia
www.s3.com – firma S3
12.1.4
Recenze grafických akcelerátorů a ostatního hardwaru
www.svethardware.cz – české stránky Svět Hardware
www.tomshardware.com – Tom’s Hardware Guide
www.anandtech.com - AnandTech
www.voodooextreme.com – Voodoo Extreme
www.avault.com – The Adrenaline Vault
www.reviewseek.com – ReviewSeek
www.sharkyextreme.com – Sharky Extreme
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
65
-
12.1.5
Ostatní stránky
Na této adrese lze stáhnout balík ovladačů pro grafické akcelerátory, které podporují OpenGL
www.glsetup.com
Domovská stránka pro vývojáře DirectX od firmy Microsoft
http://msdn.microsoft.com/directx/
Informace a techniky pro vývojáře pod systémem DirectX
http://www.geocities.com/SiliconValley/Way/3390/
Síť s velkým množstvím různých programů, ovladačů a demonstračních programů pro grafické akcelerátory
www.3dfiles.com
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
66
-
13
Příloha
13.1
Obsah přiložených disket
Součástí diplomové práce jsou dvě diskety, obsahující soubory knihovny MGL. Jsou určené primárně pro plat-
formu Windows. Jsou naformátované pro souborový systémem FAT16. Obsahuje soubory archivované ve for-
mátu .zip
Pro zpřístupnění jejich obsahu je nutné:
•
Vytvořit na pevném nebo síťovém disku adresář, kam bude jejich obsah dekomprimován (např.
mkdir
c:\mgl
)
•
Programem pro dekomprimování archivů .zip dekomprimovat obsah všech archivů na obou disketách (mgl-
src.zip, mgldata.zip, binlinux.zip a binwin32.zip) do připraveného adresáře, například použitím programu
WinZip nebo PKUNZIP pro DOS. Všechny soubory používají pro snadnou přenositelnost konvenci jmen
systémů DOS souborů 8.3. (například
pkunzip a:*.zip c:\mgl\ -d
)
•
Pro jiné platformy, které nepodporují souborový systém disket (FAT16) nebo formát .ZIP dodaných disket
je nutné obsahy archívů disket dekomprimovat na platformě Windows a obsah vytvořených adresářových
struktur a souborů přenést na cílovou platformu (například pomocí služby FTP).
•
Po těchto krocích by již měla být vytvořena kompletní struktura souborů knihovny MGL. Pro rychlé otesto-
vání funkčnosti knihovny, případně ovladačů OpenGL na použitém systému doporučuji nejprve spustit apli-
kaci DEMO z adresáře /bin/.
Obsah vytvořených souborů a adresářů je shrnut v následujícím popisu:
mgl.dsw
- pracovní plocha knihovny MGL pro vývojové prostředí Microsoft Visual C++ 6.0. Otevřením
tohoto souboru v tomto prostředí je možná snadná práce se všemi částmi knihovny.
/bin/
- předkompilované testovací a demonstrační aplikace a všechny příklady pro platformy Windows
a Linux. Verze pro Windows mají příponu .exe, verze pro Linux příponu nemají (například demonstrační
a testovací aplikaci DEMO lze spustit ve Windows vypsáním příkazu
demo.exe
, v operačním systému
Linux vypsáním
./demo
). Pro platformu Windows je zde soubor glut32.dll knihovny GLUT.
/bin/mgl.lib - předkompilovaný knihovní soubor knihovny MGL pro platformy Microsoft Windows 32.
Takto není pro tuto platformu není nutné instalovat knihovnu GLUT, požadovanou knihovnou MGL.
/bin/mgllib.a - předkompilovaný knihovní soubor knihovny MGL pro platformy Linux.
/bin/makefile - soubor makefile pro vytvoření demonstračních a testovacích aplikací a příkladů v operačním
systému Linux pomocí příkazu make.
/data/
- data pro testovací a demonstrační aplikace. Jedná se především o obrazové mapy.
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
67
-
/demo/
- zdrojové soubory testovací a demonstrační aplikace DEMO. Součástí zdrojových souborů,
v tomto i dalších adresářích se zdrojovými kódy, je i projekt pro vývojové prostředí Microsoft Visual
C++ (.dsp).
/examples/ - zdrojové soubory všech příkladů určené pro demonstraci funkcí API knihovny MGL. Jedná se o
příklady popsané v kapitole Popis funkcí MGL.
/grid/
- obsahuje soubor grid.c umožňující snadno vytvořit soubor se souřadnicemi znaků pro fonty
knihovny MGL.
/include/mgl.h -
hlavičkový soubor zpřístupňující všechny funkce a proměnné knihovny MGL.
/lib/
- adresář se zdrojovými soubory jádra knihovny MGL.
/mgldraw/ -
adresář se zdrojovými souboru editoru MGLDraw
/sphere/
- adresář obsahuje zdrojové kódy vykreslující kouli vystínovanou za pomoci konstantního a Gou-
radova stínování.
/versus/
- adresář obsahuje zdrojové kódy příkladů sloužící pro účel demonstrace výhod volání funkcí API
knihovny MGL namísto přímého knihovny OpenGL.
/wgl/
- adresář obsahuje zdrojový kód souboru wgl.c, který demonstruje možnost spolupráce knihovny i
s jinými okenními systémy, než je GLUT. Tento příklad je založen na okenním systému WGL. Proto je
možné jej používat jen na systémech Windows.
13.2
Popis funkcí knihovny MGL
Následuje programátorský popis jednotlivých funkcí a proměnných knihovny. Všechny proměnné a funkce zde
popsané jsou definované v souboru /include/mgl.h knihovny. Funkce jsou popsány v pořadí, v jakém se vysky-
tují v jednotlivých modulech. Na konci každého modulu je uveden názorný příklad a obrázek demonstrující
použití vybraných funkcí. Obrázky byly získány na platformě Windows 98 s grafickým adaptérem S3 Savage4,
podporujícím hardwarovou akceleraci OpenGL. Všechny tyto příklady lze nalézt v adresáři /examples/ knihovny
MGL.
13.2.1
Modul Window
Knihovna MGL nabízí funkce pro práci s okny, které se opírají o funkce GLUT, jak bylo popsáno výše. Uživatel
knihovny si ovšem může vybrat, zda tyto funkce použije nebo si zobrazování oken zajistí vlastními prostředky.
Před použitím příkazů MGL je ovšem nutné mít otevřené okno a použité příkazy knihovny MGL uzavřít mezi
příkazy mglBegin a mglEnd. Rozhodne-li se práci s okny ponechat knihovně MGL jsou mu k dispozici funkce
a proměnné, popsané v následujícím textu.
extern int mglOpenWindow (char *title, int x, int y, int width,
int height);
Funkce vytvoří na pracovní ploše okno, ve kterém je vytvářen obraz pomocí příkazů knihovny MGL a OpenGL.
Okno je umístěno na pozici (
x
,
y
). Bod (0,0) odpovídá hornímu levému rohu obrazovky. Délka okna je dána
parametrem
width
a šířka parametrem
height
. Jako popisek okna je použit řetězec
title
. Barevná hloub-
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
68
-
ka je určená současným rozlišením obrazovky. Skutečná velikost otevřeného okna ovšem může být obecně jiná,
a je udána v proměnných
mglWindowWidth
a
mglWindowWidth
extern int mglOpenFullscreen (char *title);
Tato funkce je analogická předchozí, s tím, že je vytvořeno okno o co možná největší velikosti vzhledem
k současnému rozlišení obrazovky. Tuto nebo předchozí funkcí je nutné použít před dalšími příkazy modulu
Window. Bez vytvořeného okna těmito funkcemi (případně funkcemi jiného okenního systému) nelze další
funkce a proměnné knihovny MGL použít.
extern int mglScreenWidth;
Proměnná udává délku plochy obrazovky. Je dána současným použitým rozlišením operačního systému (napří-
klad 1024). Uživatel může použít tuto hodnotu například pro nastavení vhodné velikosti okna.
extern int mglScreenHeight;
Proměnná udává analogicky šířku plochy obrazovky (například 768)
extern int mglWindowWidth;
Proměnná udává skutečnou šířku vnitřku okna otevřeného pomocí funkcí
mglOpenWindow
nebo
mglOpen-
FullScreen
.
extern int mglWindowHeight;
Proměnná udává skutečnou šířku vnitřku okna otevřeného pomocí funkcí
mglOpenWindow
nebo
mglOpen-
FullScreen
.
typedef void (*mglHandlerType) (void);
extern void mglSetDisplayHandler (mglHandlerType displayHandler);
Funkce nastavuje funkci pro obnovení obrazu, která je volána, kdykoliv je MGL připravena obnovit obraz vytvo-
řením dalšího rámce. Uživatelem definovaná funkce
displayHandler
musí zajistit vykreslení všech poža-
dovaných objektů obrazu. Tuto funkci je nezbytně nutné nastavit.
extern void mglSetIdleHandler (mglHandlerType idleHandler);
Podobně jako je nastavena funkce pro obnovení obrazu, je možné nastavit funkci
idleHandler
, která je volá-
na vždy, když knihovna MGL nepotřebuje čas procesoru, a řízení může být předáno uživatelské aplikaci.
extern int mglReshaped;
Proměnná je nastavena knihovnou MGL předtím, než je zavolána uživatelem definovaná funkce daná voláním
funkce
mglSetDisplayHandler
. Pokud je proměnná nastavena na 1, indikuje, že byla změněna velikost
okna.
extern int mglFrames;
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
69
-
Proměnná indikuje, kolik obrazových rámců již bylo vytvořeno. Je dána počtem volání funkce pro obnovení
obrazu.
extern void mglRun (void);
Tato funkce předá řízení programu rutinám knihovny MGL. Knihovna MGL volá funkce nastavené pomocí
mglSetDisplayHandler
a
mglSetIdleHandler
. I tuto funkci je nutné zavolat, pokud použijeme
okenní systém nabízený knihovnou MGL.
13.2.1.1
Příklad
Následující zdrojový kód (soubor e_window.c) vytvoří okno délky 320 a šířce 240, které umístí pozici obrazov-
ky (100, 100). Vnitřek okna je vyplněn světle modrou barvou. Na titulku okna vypíše skutečnou velikost a veli-
kost rozlišení obrazovky.Výsledek je uveden na obrázku.
#include <stdio.h>
#include <mgl.h>
void display (void)
{
char s [333];
mglClearScreen (mglCeleste);
sprintf (s, "Window %i x %i (screen %i x %i)", mglWindowWidth,
mglWindowHeight, mglScreenWidth, mglScreenHeight);
mglSetWindowTitle (s);
}
void main (void)
{
mglOpenWindow ("Demonstrace modulu Window", 100, 100, 320, 120);
mglSetDisplayHandler (display);
mglRun ();
}
Obrázek 35 – Okno nakreslené kódem e_window.c
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
70
-
13.2.2
Modul Mgl
V tomto modulu jsou uloženy funkce a proměnné uvedené v následujícím textu.
extern void mglBegin (void);
extern void mglEnd (void);
Tyto funkce umožňují oddělit příkazy knihovny MGL od příkazů OpenGL. Požaduje-li uživatel kromě funkcí
knihovny MGL použít i čistého OpenGL, musí uzavřít blok příkazů MGL vložit mezi volání funkcí
mglBegin
a
mglEnd
. Funkce
mglBegin
zajistí nastavení proměnných a charakteristik OpenGL používané knihovnou
MGL. Naopak
mglEnd
obnoví původní nastavení, před voláním
mglBegin
.
extern int mglVirtualWidth;
extern int mglVirtualHeight;
Tyto proměnné slouží pro nastavení požadovaného souřadný systém pro kreslené objekty. Souřadnice nejsou
nijak závislé na velikosti otevřeného okna. Místo toho má uživatel knihovny možnost nastavit vlastní systém
souřadnic. Vykreslování pomocí knihovny MGL je tedy takto nezávislé na velikosti okna. Vždy ale platí, že levý
horní roh je určen souřadnicemi (0,0) a souřadnice v pravém dolním rohu je určena souřadnicemi
(
mglVirtualWidth,mglVirtualHeight
). Tyto proměnné je nutné nastavit před použitím funkcí
mgl-
SetWindowSize, mglOpenWindow
nebo
mglOpenFullScreen
. Dokud jedna z těchto funkcí není
zavolána, jsou použity souřadnice, dané stávajícím obsahem těchto proměnných. Všechny vykreslovací funkce
knihovny MGL provádí automatické ořezávání grafických primitiv. Je tedy možné kreslit i mimo zvolené sou-
řadnice.
Následující proměnné mají pouze informační význam a není nutné je použít. Slouží pro získaní informací o
konkrétní implementaci OpenGL.
extern char *mglVendor;
Řetězec identifikuje výrobce, který dodal ovladač OpenGL.
extern char *mglRenderer;
Řetězec identifikuje grafický podsystém vytvářející obraz OpenGL.
extern char *mglVersion;
Řetězec obsahuje číslo verze OpenGL.
extern char *mglExtensions;
Řetězec obsahuje OpenGL extense, podporované grafickým podsystémem
extern int mglMaxTextureSize;
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
71
-
Proměnná obsahuje délku a šířku určující maximální podporovanou velikost textur. Typická současná hodnota je
256, 512, 1024 nebo 2048.
extern int mglBitsPerPixel;
Číslo udává počet bitů, které jsou potřeba pro specifikaci jednoho obrazového bodu. Hodnota je obvykle určená
použitou barevnou hloubkou na pracovní ploše obrazovky. Hodnoty jsou 8, 16, 24 nebo 32.
13.2.2.1
Příklad
Následující zdrojový kód (soubor e_mgl.c) vypisuje obsahy proměnných modulu Mgl.
#include <stdio.h>
#include <mgl.h>
int main (void)
{
char s [333];
mglVirtualWidth = 800;
mglVirtualHeight = 600;
mglOpenWindow ("Demonstrace modulu Mgl", 100, 100, 256, 256);
printf ("mglVendor: %s\n", mglVendor);
printf ("mglRenderer: %s\n", mglRenderer);
printf ("mglVersion: %s\n", mglVersion);
printf ("mglExtensions: %s\n", mglExtensions);
printf ("\n");
printf ("Screen resulution is %i x %i x %i-bit\n",
mglScreenWidth,mglScreenHeight, mglBitsPerPixel);
printf ("Virtual window size is %i x %i\n", mglVirtualWidth,
mglVirtualHeight);
printf ("Maximum texture size is %i x %i\n", mglMaxTextureSize,
mglMaxTextureSize);
printf ("\n");
printf ("Press Enter to continue ...\n");
gets (s);
return 0;
}
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
72
-
Následuje příklad výstupu, který byl získán po přeložení a spuštění na grafickém adaptéru S3 Savage 4
s nainstalovanými referenčními ovladači OpenGL:
mglVendor: S3
mglRenderer: Savage4
mglVersion: 1.1 8.10.23
mglExtensions: GL_EXT_abgr GL_EXT_bgra GL_EXT_clip_volume_hint
GL_EXT_compiled_vertex_array GL_EXT_packed_pixels GL_EXT_stencil_wrap
GL_EXT_vertex_array GL_KTX_Buffer_region GL_S3_s3tc GL_SGI_cull_vertex
GL_SGI_index_array_formats GL_SGI_index_func GL_SGI_index_material
GL_SGI_index_texture GL_WIN_swap_hint
Screen resulution is 1024 x 768 x 16-bit
Virtual window size is 800 x 600
Maximum texture size is 2048 x 2048
Press Enter to continue ...
13.2.3
Modul Draw
Tento modul zajišťuje vykreslování základních grafických primitiv – bodů, čar, trojúhelníků a čtverců, které
mohou být kresleny zvolenými barvami, volitelně pak vyplněné trojúhelníky a čtverce, s průhlednou vrstvou a
interpolací.
typedef struct {
float r;
float g;
float b;
float a;
} mglColor;
Tato struktura definuje barvu pro kreslení grafických primitiv. Položky definují barvu pro barevné složky červe-
ná (r), zelená (g), modrá (b) a alfa vrstvu (a). Povolené hodnoty reálná čísla od 0 do 1.
extern mglColor mglBlack;
extern mglColor mglRed;
extern mglColor mglGreen;
extern mglColor mglBlue;
extern mglColor mglYellow;
extern mglColor mglCyan;
extern mglColor mglMagenta;
extern mglColor mglWhite;
extern mglColor mglBlank;
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
73
-
extern mglColor mglPink;
extern mglColor mglCeleste;
Jedná se o předdefinované barvy. Barvy jsou uvedeny v následující tabulce:
Identifikátor proměnné
Barva
mglBlack
Černá
mglRed
červená
mglGreen
zelená
mglBlue
modrá
mglYellow
žlutá
mglCyan
modrozelená
mglMagenta
fialová
mglWhite
bílá
mglBlank
neviditelná
mglPink
růžová
mglCeleste
blankytná modř
Tabulka 2 – předdefinované barvy knihovny MGL
extern void mglClearScreen (mglColor clearColor);
Tato funkce vymaže celý obrazový rámec barvou
clearColor
extern void mglAlphaOn (void);
Povoluje použití průhledných vrstev při kreslení grafických primitiv. Pokud je tato funkce zavolána, jsou prů-
hledné složky použity pro zajištění průhlednosti vykreslovaných objektů. Standardně jsou objekty knihovny
MGL kresleny s průhlednými vrstvami alfa.
extern void mglAlphaOff (void);
Po zavolání této funkce jsou průhledné složky vykreslovaných primitiv ignorovány. Objekty jsou kresleny tak,
jako by byla průhledná složka nastavena na 1.
extern void mglSmoothOn (void);
Po zavolání této funkce jsou vykreslovaná grafická primitiva vyhlazována. Standardně jsou ovšem grafická pri-
mitiva knihovny MGL, vzhledem k možnostem nabízených současnými grafickými adaptéry vytvářena bez
vyhlazování, protože tím by docházelo ke značnému zpomalení vykreslování.
extern void mglSmoothOff (void);
Po zavolání této funkce nejsou vykreslovaná grafická primitiva vyhlazována.
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
74
-
extern float mglRotationAngle;
Tato proměnná určuje úhel, podle kterého jsou grafické objekty otáčeny při vykreslování podle své osy. Tato
hodnota je standardně nastavena na 0, která určuje, že objekty rotovány nejsou.
extern mglColor mglPointColor;
Tato proměnná určuje barvu, kterou jsou kresleny body pomocí funkce
mglDrawPoint.
extern float mglMaxPointSize;
Proměnná obsahuje maximální povolenou hodnotu, která může být použita pro nastavení velikosti bodu pomocí
funkce
mglSetPointSize.
extern void mglSetPointSize (float size);
Nastaví velikost bodů (v
obrazových bodech), které jsou na obrazovce kresleny pomocí funkce
mglDrawPoint
.
extern void mglDrawPoint (int x, int y);
Na pozici (
x,y
) vykreslí obrazový bod.
extern void mglInterpolationOn (void);
Povolí použití barevné interpolace při kreslení grafických primitiv knihovny MGL. Barevná interpolace je stan-
dardně povolena.
extern void mglInterpolationOff (void);
Zakáže použití barevné interpolace. Místo plynulých barevných přechodů jsou primitiva obarvena jen jednou
barvou, danou barvou prvního bodu nebo posledního bodu primitiva (záleží na implementaci OpenGL).
extern mglColor mglLineColor [2];
Proměnná určuje barvy vrcholů kreslených úseček pomocí funkce
mglDrawLine.
extern void mglSetLineColors (mglColor color);
Nastaví obě barvy pole
mglLineColor
na hodnotu parametru
color
.
extern float mglMaxLineSize;
Proměnná obsahuje maximální povolenou hodnotu, která může být použita pro nastavení tloušťky čar pomocí
funkce
mglSetPointSize
extern void mglSetLineSize (float size);
Nastaví tloušťku čar (v obrazových bodech), které jsou na obrazovce kresleny pomocí funkce
mglDrawLine,
mglDrawTriangle a mglDrawRectangle.
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
75
-
extern void mglDrawLine (int x1, int y1, int x2, int y2);
Vykreslí úsečku danou souřadnicemi (
x1, y1
) a (
x2, y2
).
extern mglColor mglTriangleColor [3];
Proměnná určuje barvy vrcholů kreslených trojúhelníků. Při kreslení vyplněných trojúhelníků jsou tyto barvy
určeny pro barvu výplně.
extern void mglSetTriangleColors (mglColor color);
Nastavuje všechny tři barvy pole
mglTriangleColor
na hodnotu danou parametrem
color.
extern void mglDrawTriangle (int x1, int y1, int x2, int y2, int x3, int
y3);
Vykreslí trojúhelník daný vrcholy o souřadnicích (
x1,y1
), (
x2,y2
), (
x3,y3
).
extern void mglDrawFilledTriangle (int x1, int y1, int x2, int y2, int x3,
int y3);
Vykreslí vyplněný trojúhelník daný vrcholy o souřadnicích (
x1,y1
), (
x2,y2
), (
x3,y3
).
extern mglColor mglRectangleColor [4];
Proměnná určuje barvy vrcholů kreslených obdélníků. Při kreslení vyplněných obdélníků jsou tyto barvy určeny
pro barvu výplně.
extern void mglSetRectangleColors (mglColor color);
Nastavuje všechny čtyři barvy pole
mglTriangleColor
na hodnotu parametru
color
.
extern void mglDrawRectangle (int x, int y, int width, int height);
Vykreslí obdélník, jehož levá horní hrana je dána vrcholem o souřadnicích (
x,y
). Jeho délka je dána paramet-
rem
width,
šířka je dána parametrem
height
.
extern void mglDrawFilledRectangle (int x, int y, int width, int height);
Vykreslí vyplněný obdélník, jehož levá horní hrana je dána vrcholem o souřadnicích (
x,y
). Jeho délka je dána
parametrem
width,
šířka je dána parametrem
height
.
13.2.3.1
Příklad
Následující zdrojový kód (e_draw.c) používá vykreslovacích funkcí pro demonstraci modulu Draw. Výstup
příkladu je na následujícím obrázku.
#include <mgl.h>
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
76
-
void display (void)
{
mglColor c;
int size;
mglSmoothOn ();
mglInterpolationOn ();
size = mglMaxPointSize;
if (size > 10)
size = 10;
mglSetLineSize (size / 2);
mglRectangleColor [0] = mglRectangleColor [1] = mglCeleste;
mglRectangleColor [2] = mglRectangleColor [3] = mglWhite;
mglDrawFilledRectangle (0, 0, 999, 999);
mglInterpolationOff ();
mglRectangleColor [0] = mglRed;
mglRectangleColor [1] = mglGreen;
mglRectangleColor [2] = mglWhite;
mglRectangleColor [3] = mglYellow;
mglDrawRectangle (100, 100, 800, 800);
mglSetLineColors (mglGreen);
mglDrawLine (500, 200, 500, 800);
mglRotationAngle = 90;
mglDrawLine (500, 200, 500, 800);
mglRotationAngle = 0;
c = mglPink;
c.a = 0.5;
mglSetTriangleColors (c);
mglDrawFilledTriangle (500, 200, 800, 800, 200, 800);
c = mglRed;
c.a = 0.5;
mglPointColor = c;
mglSetPointSize (size);
mglDrawPoint (300, 300);
mglDrawPoint (300, 700);
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
77
-
mglDrawPoint (700, 300);
mglDrawPoint (700, 700);
}
int main (void)
{
mglVirtualWidth = mglVirtualHeight = 999;
mglOpenWindow ("Demonstrace modulu Draw", 100, 100, 256, 256);
mglSetDisplayHandler (display);
mglRun ();
return 0;
}
Obrázek 36 –Grafická primitiva vykreslená zdrojovým kódem e_draw.c
13.2.4
Modul Images
Funkce modulu Images slouží pro definici obrazových map pro a jejich načítání a ukládání do diskových soubo-
rů.
typedef struct {
int w;
int h;
int d;
int type;
int xrev;
int yrev;
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
78
-
unsigned char *data;
unsigned char **mipmap;
} mglImage;
Struktura
mglImage
je základním typem pro definici obrazových map. V položce
w
je délka mapy, v položce
h
je šířka mapy. Položka
d
nabývá hodnot od 1 do 4 a indikuje počet bytů na jeden obrazový bod mapy. V položce
type
je typ, kterým je obrázek reprezentován pro OpenGL. Možné hodnoty jsou
GL_LUMINANCE
,
GL_INTENSITY
,
GL_LUMINANCE_ALPHA
,
GL_RGB
,
GL_RGBA
,
GL_BGRA_EXT
,
GL_BGR_EXT
. Položka
xrev
a
yrev
indikuje, že obrazová data mají být otočena podle osy
x
, respektive
y
. Není-li
yrev
rovno 0, jsou
v paměti obrazových bodů, na které ukazuje položka data uloženy nejdříve řádky s dolní části obrázku. Není-li
xrev
rovno 0, jsou v každém řádku umístěny nejprve obrazové body z pravé části řádku. Položka
data
obsa-
huje obrazové body mapy. Za sebou v paměti je uloženo postupně
d
bytů reprezentujících bod. Těchto bodů je
v paměti data uloženo
w*d
.
•
Typ
GL_LUMINANCE
představuje černobílé obrazy. Hodnota
d
pro tento typ je 1. Každý bod mapy nabývá
hodnoty od 0 do 255. 0 reprezentuje černou barvu, 255 bílou.
•
GL_LUMINANCE_ALPHA
je pro černobílé obrazy s průhlednou vrstvou. První byte má význam jako u typu
GL_LUMINANCE
. Hodnota druhého bytu určuje hodnotu s průhledné složky bodu. Hodnota 0 značí, že bod
je plně průsvitný (není vůbec viditelný a nepřekrývá pozadí), 127 poloviční průsvitnost a 255 označuje že
bod není průsvitný vůbec (plně překrývá pozadí). Pokud jsou všechny byty průhledné vrstvy nastaveny na
255, obrazová mapa je ekvivalentní typu
GL_LUMINANCE
.
•
GL_RGB
je pro barevné body v režimu RGB. První byte reprezentuje červenou složku, druhý zelenou, třetí
modrou. Povolený rozsah hodnot pro všechny složky je od 0 do 255. Hodnota
d
pro tento typ je 3.
•
GL_RGBA
je shodný s typem
GL_RGB
, s tím, že za prvními třemi byty pro barevné složky je uložen byte
definující průhlednou vrstvu. Hodnota
d
pro tento typ je 4.
•
GL_BGR_EXT
je shodný s typem
GL_RGB
, s tím, že barevné složky jsou uloženy v obráceném pořadí.
•
GL_BGRA_EXT
je shodný s typem
GL_RGBA
, s tím že, barevné složky jsou uloženy v obráceném pořadí.
Při použití typů
GL_INTENSITY
,
GL_BGRA_EXT
a
GL_BGR_EXT
je nucen uživatel knihovny voláním funkcí
OpenGL zjistit, zda jsou tyto typy OpenGL podporovány. Pokud je ale obrázek načten z diskového souboru
pomocí funkcí
mglLoadImage
nebo
mglLoadTexture
, knihovna MGL zjistí sama, které typy jsou
podporovány. Následně vybere nejvhodnější typ, provede případnou konverzi obrazu a vyplní všechny položky
struktury sama.
extern mglImage *mglNewImage (void);
Vytvoří novou strukturu
mglImage
, vynuluje všechny její položky a vrátí její ukazatel. Funkci lze použít, po-
žaduje-li uživatel tvorbu vlastních obrazových map, bez nutnosti jejich načítání z diskových souborů. Je nucen
následně vyplnit všechny položky struktury vytvořené touto funkcí.
extern mglImage *mglCreateImage (int width, int height, int depth);
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
79
-
Funkce vytvoří obrazovou mapu o délce
width
a šířce
height
. Počet bytů na obrazový bod je
depth
. Vypl-
ní položky
w
,
h
a
d
struktury. Dále alokuje paměť pro obrazové body, kterou přiřadí položce
data
. Ostatní
položky vymaže a vrátí ukazatel na vzniklou strukturu.
extern mglImage *mglLoadImage (char* fileName, int alpha);
Z diskového souboru, jehož jméno je dáno parametrem
fileName
načte obrazovou mapu. Pokud je pa-
rametr alpha 0, obrázek je načten bez průhledné vrstvy. Pokud je hodnota parametru alpha 1, obrázek je načten
s průhlednou vrstvou. Neobsahuje-li obrázek na disku průhlednou vrstvu, je vytvořena průhledná vrstva
s hodnotou 0 pro všechny body. Tuto hodnotu je poté možné změnit, pro každý obrazový bod zvlášť, přístupem
do položky
data
vniklé obrazové mapy.
Hodnota 2 je slouží pro automatické vytvoření průhledné vrstvy. Pokud obrázek již průhlednou vrstvu
obsahuje, je beze změn načten. Pro 8-bitové černobílé obrázky, je-li v implementaci OpenGL podporován typ
GL_INTENSITY,
je obrázek bez konverzí načten a je mu přiřazen typ
GL_INTENSITY
. Není-li podporován,
je přidána průhledná vrstva, jejíž hodnota je shodná s hodnotami jednotlivých bodů obrazové mapy. Poté je mu
přiřazen typ
GL_LUMINANCE_ALPHA
. Pro barevné obrázky 24-bitové obrázky jsou body průhledné vrstvy
vytvořeny přiřazením průměru barevných složek jednotlivých bodů. Tuto hodnotu lze použít například pro tvor-
bu fontů. Podporované formáty souborů jsou .BMP, .TGA a .SGI.
extern mglImage *mglGetRGBImage (int x, int y, int w, int h);
Vytvoří obrázek s položkou
type
nastavebou na
GL_RGB
o délce
w
a šířce
h
. Alokuje paměť o velikosti
3*w*h
bytů. Z obrazového rámce, z pozice (
x,y
) je do alokované paměti načtena obrazová mapa požadova-
ných rozměrů. Funkce vrátí ukazatel na takto vytvořenou strukturu obrazové mapy.
extern void mglSaveImage (char* fileName, mglImage *image);
Funkce uloží obrazovou mapu danou strukturou
image
do diskového souboru, formátu .TGA. Tento obrázek je
později možné načíst pomocí funkce
mglLoadImage
.
extern void mglDeleteImage (mglImage *image);
Funkce zruší strukturu obrazové mapy dané parametrem
image
. Pokud byly přiřazeny obrazové body do polož-
ky
data
,
jsou tato uvolněna. Poté je uvolněna i paměť struktury
image
.
13.2.4.1
Příklad
Zdrojový kód e_images.c vytvoří černobílou obrazovou mapu o velikosti 256 na 256. Mapu vyplní algoritmem
pro tvorbu šachovnice. Výsledek uloží na disk do obrázku chess.tga. Vygenerovaná šachovnice je uvedena na
následujícím obrázku.
#include <mgl.h>
void mainMakeCheckImage (unsigned char *map, int size, int segs)
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
80
-
{
int i,j;
for (j = 0; j < size; j++)
{
for (i = 0; i < size; i++)
{
if ((i ^ j) & segs)
*map = 0;
else
*map = 255;
map++;
}
}
}
int main (void)
{
mglImage *image;
mglOpenWindow ("Demonstrace modulu Images", 100, 100, 256, 256);
image = mglCreateImage (256, 256, 1);
image->type = GL_LUMINANCE;
mainMakeCheckImage (image->data, 256, 64);
mglSaveImage ("chess.tga", image);
mglDeleteImage (image);
mglMessage ("Note", "Created image has been saved to file chess.tga");
return 0;
}
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
81
-
Obrázek 37 – Obrazová mapa šachovnice vygenerovaná zdrojovým kódem e_images.c a uložená v souboru
chess.tga
13.2.5
Modul Textures
Modul slouží pro kreslení obrazových map do obrazového rámce.. Zobrazování je implementováno pomocí
textur. Funkce podporují vytvoření textur z obrazové mapy, přímé nahrání textur z diskového souboru, nastavení
velikosti a barev.
typedef struct {
mglImage image;
int name;
} mglTexture;
Jedná se o základní typ struktury textury. Obě její položky jsou nastaveny použitím funkce
mglMakeTexture
nebo
mglLoadTexture
. V položce
image
je zkopírována hlavička ze struktury obrazové mapy, z které byla
textura vytvořena. Položka
name
obsahuje identifikátor textury, umožňující jednoznačné rozlišení od ostatních
použitých textur.
extern mglTexture *mglMakeTexture (mglImage *image, int mode);
Z obrazové mapy dané parametrem image vytvoří texturu. Textura je vytvořena v režimu daném parametrem
mode. Délka i šířka textury musí být dělitelná dvěmi.
Režim může nabývat jednu z následujících hodnot, které vybírají metodu pro zmenšení a zvětšení obrazových
dat:
•
GL_NEAREST
(nejbližší souseda)
•
GL_LINEAR
(bilineární filtrování)
•
GL_NEAREST_MIPMAP_NEAREST
(nejbližší soused s použitím technologie mipmapping)
•
GL_NEAREST_MIPMAP_LINEAR
(bilineární filtrování s použitím technologie mipmapping)
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
82
-
•
GL_LINEAR_MIPMAP_NEAREST
(trilineární filtrování s mipmappingem)
•
GL_LINEAR_MIPMAP_LINEAR
(trilineární filtrování s mipmappingem)
Libovolné změny obrazové mapy po zavolání tohoto příkazu nemají vliv na vytvořenou texturu. Obrazovou
mapu a její strukturu je proto možné uvolnit pomocí volání funkce
mglDeleteImage
.
extern mglTexture *mglLoadTexture (char *fileName, int imageMode,
int textureMode);
Tato funkce nejdříve zavolá funkci
mglLoadImage
, která načte z diskového souboru obrázek daný paramet-
rem
fileName
v režimu daným parametrem
imageMode
. Tím vytvoří obrazovou mapu, kterou předá jako
parametr funkci
mglMakeTexture
. Výsledkem je textura vytvořená v
režimu daném parametrem
textureMode
. Struktura obrazové mapy je odstraněna voláním funkce
mglDeleteImage
.
Zápis
mglLoadTexture (fileName, imageMode, textureMode)
je tedy funkčně ekvivalentní
zápisu
mglMakeTexture (mglLoadImage (imageMode), textureMode);
extern mglColor mglTextureColor [4];
Jedná se o pole barev, které určují obarvení všech kreslených objektů, pokrytých texturami.
extern void mglSetTextureColors (mglColor color);
Vyplní pole všechny čtyři položky pole
mglTextureColor
barvou danou parametrem
mglColor
.
extern float mglTextureZoomX;
extern float mglTextureZoomY;
Proměnné umožňují nastavit volitelné zvětšení a zmenšení kreslených textur ve směru osy x a osy y. Standardně
je hodnota obou proměnných nastavena na hodnotu 1.
extern void mglSetTextureZoom (float zoom);
Funkce nastavuje hodnotu proměnných
mglTextureZoomX
a
mglTextureZoomY
na hodnotu parametru
zoom
.
extern void mglDrawTexture (mglTexture *texture, int x, int y);
Vykreslí texturu do obrazového rámce na pozici (
x,y
). Velikost textury je dána jednak položkami
image.width
a
image.height
textury a volitelným zvětšením nebo zmenšením, dané parametry
mglTextureZoomX
a
mglTextureZoomY
.
extern void mglDrawSubTexture (mglTexture *texture, int x, int y, int fro-
mX, int fromY,int width, int height);
Na pozici (
x,y
) vykreslí výřez z textury dané parametrem
texture
. Výřez je definován bodem (
fromX,
fromY
), který určuje levý horní bod výřezu textury, parametry
width
a
height
určují velikost výřezu.
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
83
-
extern void mglDrawTexturedRectangle (mglTexture *texture, int x, int y,
int width, int height);
Vykreslí obdélník pokrytý texturou danou parametrem
texture
. Obdélník je vykreslen na pozici (
x,y
), jeho
délka a šířka je dána parametrem
width
a
height
. Velikost textur, které vyplňují jeho vnitřek je dán volitel-
ným zvětšením a zmenšením. Pokud textura nevyplní celý prostor obdélníku, je použito dlaždicovitého vyplnění.
extern void mglChangeTexture (mglTexture *texture);
Tato funkce slouží pro nastavení aktuální textury systému OpenGL. Funkce lze použít pro použití textur načtené
knihovnou MGL jinými příkazy OpenGL.
extern void mglDeleteTexture (mglTexture *texture);
Vymaže texturu, která byla vytvořena pomocí funkcí
mglMakeTexture
nebo
mglLoadTexture
. Uvolní
texturu z paměti grafického podsystému a paměť struktury
texture
.
13.2.5.1
Příklad
Zdrojový kód e_textur.c demonstruje použití a zobrazení textur, změn jejich velikosti, rotace a barvy na textuře
šachovnice vygenerované v minulém případě. Výsledek je zobrazen na následujícím obrázku.
#include <mgl.h>
mglTexture *texture;
void display (void)
{
mglColor c;
int x, y;
mglRotationAngle = 45;
mglSetTextureColors (mglWhite);
mglSetTextureZoom (0.333);
mglDrawTexturedRectangle (texture, -2000, -2000, 4000, 4000);
mglRotationAngle = 0;
c = mglBlue;
c.a = 0.5;
mglTextureColor [0] = mglTextureColor [1] = c;
mglSetTextureZoom (2.5);
x = (mglVirtualWidth - mglTextureZoomX * texture->image.w) / 2;
y = (mglVirtualHeight - mglTextureZoomY * texture->image.h) / 2;
mglDrawTexture (texture, x, y);
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
84
-
}
int main (void)
{
mglVirtualWidth = 1000;
mglVirtualHeight = 1000;
mglOpenWindow ("Demonstrace modulu Textures", 100, 100, 256, 256);
texture = mglLoadTexture ("../data/examples/chess.tga", 0, GL_LINEAR);
mglSetDisplayHandler (display);
mglRun ();
return 0;
}
Obrázek 38 – Textury zobrazené kódem e_textur.c
13.2.6
Modul Fonts
Modul implementuje funkce pro práci s fonty knihovny MGL, založenými na mapování textur.
typedef struct
{
int x;
int y;
int width;
int height;
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
85
-
} mglXY;
typedef struct
{
mglTexture *texture;
int w;
int h;
int spacingX;
int spacingY;
mglXY chars [256];
} mglFont;
Typ
mglFont
je strukturou pro definici fontů knihovny MGL. Položka
texture
je ukazatelem na vytvořenou
texturu, v které jsou zobrazeny všechna písmena fontu. Položka
w
a
h
určuje implicitní velikost znaku. Položky
spacingX
a
spacingY
určují počet obrazových bodů mezi jednotlivými písmeny a řádky. Pole
chars
slouží
pro definici souřadnic výřezů všech písmen, které jsou zobrazeny v obrazové mapě textury. Položky
x
a
y
určují
souřadnici levého horního rohu výřezu. Délka výřezu je dána položkou
width
, šířka položkou
height
. Pokud
je délka nebo šířka nulová, dané písmeno není ve fontu obsaženo.
extern mglFont *mglNewFont (void);
Vytvoří novou strukturu
mglFont
. Alokuje pro ni paměť a vynuluje všechny položky. Funkci lze použít, pokud
uživatel chce vytvořit font bez jeho nutnosti jej načítat z disku funkcemi popsanými dále.
extern void mglLoadFontDefinitionTextFile (mglFont *font, char
*textFileName);
Načte definice znaků s textového souboru daným jménem parametru
textFileName
a přiřadí je do fontu
daném parametrem
font
. Formát textového souboru je následující:
•
Na prvním řádku je postupně uloženo jméno fontu, implicitní délka znaku, implicitní šířka znaku a mezery
v obrazových bodech mezi jednotlivými znaky a řádky. Všech pět údajů je odděleno znakem mezera.
•
Na dalších řádcích jsou postupně uvedeny údaje definující jednotlivé znaky. Každý řádek určuje jeden znak.
První údaj je souřadnice
x
, druhý je souřadnice
y
. Bod daný (
x
,
y
) označuje levý horní roh obrazového vý-
řezu znaku. Další dva údaje jsou délka a šířka znaku. Jsou-li tyto údaje nulové, použije se implicitní délka a
šířka znaku. Dalším údajem je ASCII znak, přiřazující daný výřez konkrétnímu písmenu. Pokud je tento
znak ‘?’ musí být v závorce uveden poslední údaj, kterým je číselná hodnota znaku.
extern mglFont *mglLoadFont (char *textFileName, char *imageFileName);
Tato funkce vytvoří font z obrázku uloženém na disku pod jménem daném parametrem
imageFileName
a
definic znaků v textovém souboru daném jménem
textFileName
. Textový soubor je zpracován funkcí
mglLoadTextFontData
.
extern int mglPutc (mglFont *font, char c, int x, int y);
Vypíše písmeno dané c z fontu font do obrazového rámce na pozici (
x,y
).
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
86
-
extern void mglPuts (mglFont *font, char *s, int x, int y);
Vypisuje řetězec znaků dané c z fontu font do obrazového rámce na pozici (
x,y
). Řetězec může obsahovat zna-
ky konce řádku ‘\n’. Znak konce řádku způsobí, že další písmena jsou tisknuta na dalším řádku.
extern int mglFontWrap;
Tímto parametrem lze nastavit počet znaků, které jsou funkcí mglPuts tištěny na jednom řádku. Další znaky jsou
potom vypisovány na dalším řádku.
extern int mglFontWordWrap;
Pokud je tato hodnota a současně hodnota proměnné
mglFontWrap
nenulové, jsou řetězce vypisované při
volání funkce
mglPuts
rozděleny na slova. Ty jsou vždy vypisována tak dlouho, aby počet vypsaných znaků
v řádku nepřekročil délku danou obsahem proměnné
mglFontWrap
. Při překročení této hodnoty jsou další
slova tištěna na novém řádku. Délka každého slova musí být menší než hodnota
mglFontWrap
.
extern void mglDeleteFont (mglFont *font);
Uvolní alokovanou paměť datové struktury fontu daného parametrem
font
.
13.2.6.1
Příklad
Zdrojový kód e_fonts.c demonstruje použití fontů knihovny MGL. Ukázáno je nahrávání fontu, význam pro-
měnných
mglFontWrap, mglWordAutoWrap
, tisk řetězců a změna barev a velikosti. Výstup programu a
obrázek default.bmp, v kterém jsou uloženy jednotlivé znaky fontu jsou uvedeny na následujících obrázcích.
#include <mgl.h>
mglFont *font;
void display (void)
{
mglClearScreen (mglWhite);
mglSetTextureZoom (1);
mglSetTextureColors (mglBlack);
mglFontWrap = 0;
mglFontWordWrap = 0;
mglPuts (font, "This is very, very long text string", 0, 0);
mglSetTextureColors (mglRed);
mglFontWrap = mglVirtualWidth / font->w;
mglPuts (font, "This is very, very long text string", 0, font->h);
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
87
-
mglSetTextureColors (mglPink);
mglFontWordWrap = 1;
mglPuts (font, "This is very, very long text string", 0, 4*font->h);
mglSetTextureColors (mglCeleste);
mglFontWrap = 0;
mglTextureZoomX = 1.3;
mglTextureZoomY = 3;
mglPuts (font, "Zoomed text", 0, 7 * font->h);
}
int main (void)
{
mglVirtualWidth = 256;
mglVirtualHeight = 256;
mglOpenWindow ("Demonstrace modulu Fonts", 100, 100, 256, 256);
font = mglLoadFont ("../data/fonts/default.txt",
"../data/fonts/default.bmp");
mglSetDisplayHandler (display);
mglRun ();
return 0;
}
Obrázek 39 – Výstup demonstračního příkladu e_fonts.c (vlevo)
Obrázek 40 – Obrázek data/fonts/default.bmp (vpravo)
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
88
-
Prvních zhruba dvacet řádků souboru /data/fonts/default.txt, které definují souřadnice znaků fontu je následují-
cích:
Default 16 24 0 0
0 24 0 0 1
16 24 0 0 2
32 24 0 0 3
48 24 0 0 4
64 24 0 0 5
80 24 0 0 6
96 24 0 0 7
112 24 0 0 8
128 24 0 0 9
144 24 0 0 :
160 24 0 0 ;
176 24 0 0 <
192 24 0 0 =
208 24 0 0 >
224 24 0 0 ? (63)
240 24 0 0 @
Strukturu tohoto souboru pro obecné velikosti fontů lze automaticky vytvořit použitím programu grid. Zdrojový
kód uložen v souboru /grid/grid.c souborů knihovny MGL.
13.2.7
Modul Input
Modul slouží pro ošetření vstupů klávesnice, myši a získání hodnot časovače. Modul lze použít jen tehdy, pokud
je použito okenního systému knihovny MGL v modulu Window. Funkce ošetřující vstupní zařízení jsou volány
až po zavolání funkce
mglRun
. Po zavolání této funkce je možné číst obsah všech proměnných tohoto modulu.
extern int mglTime;
Proměnná obsahuje počet milisekund, které uběhly od inicializace modulu zavoláním funkce
mglRun
extern int mglSystemTime;
Proměnná obsahuje počet milisekund, které proběhly od poslední půlnoci.
#define mglHours(ticks) (ticks/1000/3600)
#define mglMinutes(ticks) ((ticks/1000/60)%60)
#define mglSecs(ticks) ((ticks/1000)%60)
Tyto makra slouží pro převedení hodnot proměnných
mglTime
a
mglSystemTime
na hodiny, minuty a
sekundy.
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
89
-
extern float mglFps;
Proměnná udává současný počet obrazových rámců, které byly vytvořeny knihovnou MGL za jednu sekundu.
extern void mglShowFPS (mglFont *font, int x, int y);
Funkce zobrazí hodnotu proměnné
mglFps
v obrazovém rámci na pozici (
x,y
). Číslo je zobrazeno s přesností
na dvě desetinná místa.
typedef void (*mglKeyboardHandlerType) (int key);
extern void mglSetKeyboardHandler (mglKeyboardHandlerType handler);
Funkce nastaví funkci danou parametrem
handler
, která bude volána po každém stisknutí klávesy. Klávesa
bude uložena do proměnné
key
a předána volané funkci
handler
. Hodnota proměnné
key
má tento význam:
•
Pokud je menší než 256, udává přímo ASCII hodnotu znaku, který byl generován stištěním klávesy
•
Pokud je větší než 256, proměnná
key
obsahuje jednu z následujících hodnot, indikujících stištění speciál-
ních kláves, které negenerují ASCII znaky:
MGL_KEY_F1, MGL_KEY_F2, MGL_KEY_F3, MGL_KEY_F4, MGL_KEY_F5, MGL_KEY_F6,
MGL_KEY_F7, MGL_KEY_F8, MGL_KEY_F9, MGL_KEY_F10, MGL_KEY_F11, MGL_KEY_F12,
MGL_KEY_LEFT, MGL_KEY_UP, MGL_KEY_RIGHT, MGL_KEY_DOWN, MGL_KEY_PAGE_UP,
MGL_KEY_PAGE_DOWN, MGL_KEY_HOME, MGL_KEY_END, MGL_KEY_INSERT
•
Klávesy Enter (‘\r’), Escape (‘\27’) , Tab (‘\t‘) a Backspace (‘\b‘) jsou generovány jako standardní ASCII
znaky.
extern int mglLastKey;
Proměnná obsahuje hodnotu, která byla naposled předána jako parametr
key
uživatelem definované funkci
nastavené pomocí
mglSetKeyboardHandler
.
extern int mglShift;
extern int mglCtrl;
extern int mglAlt;
Tyto proměnné jsou nastavovány při uživatelem definované funkci nastavené pomocí
mglSetKeyboardHandler
a indikují, zda během stisku klávesy byly stištěny klávesy Shift, Ctrl a Alt.
extern int mglMouseIn;
Pokud je ukazatel myši uvnitř okna, ve kterém je tvořen obraz knihovnou MGL, je tato proměnná nastavena na
hodnotu 1. Jinak je nastavena na 0.
extern int mglMouseX;
extern int mglMouseY;
Proměnná obsahuje aktuální pozici ukazatele myši (
mglMouseX
,
mglMouseY
) v okně vytvořeném knihovnou
MGL. Pozice ukazatele je vztažena vzhledem ke zvoleným uživatelským souřadnicím, daných obsahem pro-
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
90
-
měnných
mglVirtualX
,
mglVirtualY
modulu Mgl. Proměnná
mglMouseX
nabývá hodnoty od 0 do
mglVirtualX
, proměnná
mglMouseY
hodnoty od 0 do
mglVirtualY
. Pokud je myš umístěna v levém
horním rohu, jsou obě proměnné nastaveny na 0.
extern int mglMouseLeft;
extern int mglMouseRight;
extern int mglMouseMiddle;
Pokud je stištěné levé (left), pravé (right) nebo prostřední (middle) tlačítko myši, jsou odpovídající proměnné
nastaveny na hodnotu 1.
typedef void (*mglMouseHandlerType) (int event);
extern void mglSetMouseHandler (mglMouseHandlerType handler);
Nastaví funkci handler, která je volána vždy, když dojde ke stištění nebo uvolnění tlačítek myši. V parametru
event je předávána jedna z následujících hodnot, které popisují událost, která vyvolala zavolání funkce dané
parametrem
handler
:
•
MGL_LEFT_BUTTON_DOWN
– indikuje stištění levého tlačítka myši
•
MGL_LEFT_BUTTON_UP
– indikuje uvolnění levého tlačítka myši
•
MGL_RIGHT_BUTTON_DOWN
– indikuje stištění pravého tlačítka myši
•
MGL_RIGHT_BUTTON_UP
- indikuje uvolnění pravého tlačítka myši
•
MGL_MIDDLE_BUTTON_DOWN
- indikuje stištění prostředního tlačítka myši
•
MGL_MIDDLE_BUTTON_UP
- indikuje uvolnění prostředního tlačítka myši
extern void mglSetMouseCursor (int cursor);
Nastaví kurzor myši, který je zobrazen operačním systémem, pokud je myš uvnitř okna, kde je obraz vytvářen
knihovnou MGL. Možná hodnoty předávané parametrem
cursor
je jedna z následujících:
•
MGL_CURSOR_INHERIT
•
MGL_CURSOR_NONE
•
MGL_CURSOR_FULL_CROSSHAIR
•
MGL_CURSOR_RIGHT_ARROW
•
MGL_CURSOR_LEFT_ARROW
•
MGL_CURSOR_INFO
•
MGL_CURSOR_DESTROY
•
MGL_CURSOR_HELP
•
MGL_CURSOR_CYCLE
•
MGL_CURSOR_SPRAY
•
MGL_CURSOR_WAIT
•
MGL_CURSOR_TEXT
•
MGL_CURSOR_CROSSHAIR
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
91
-
•
MGL_CURSOR_UP_DOWN
•
MGL_CURSOR_LEFT_RIGHT
•
MGL_CURSOR_TOP_SIDE
•
MGL_CURSOR_BOTTOM_SIDE
•
MGL_CURSOR_LEFT_SIDE
•
MGL_CURSOR_RIGHT_SIDE
•
MGL_CURSOR_TOP_LEFT_CORNER
•
MGL_CURSOR_TOP_RIGHT_CORNER
•
MGL_CURSOR_BOTTOM_RIGHT_CORNER
•
MGL_CURSOR_BOTTOM_LEFT_CORNER
Konkrétní vzhled každého kurzoru je závislý na použitém operačním systému. Nastavením parametru
cursor
na
MGL_CURSOR_NONE
, způsobí že operační systém žádný kurzor nezobrazuje, a uživatel může použít pro
zobrazení kurzoru vlastní prostředky, například funkci
mglDrawTexture
. Všechny kurzory jsou předvedeny
demonstrační aplikací DEMO knihovny MGL, po stištění klávesy F3.
13.2.7.1
Příklad
Následující zdrojový kód detekuje události myši a klávesnice. Obsluha klávesnice a myši je nestavena na uživa-
telské funkce. Stisknuté klávesy, tlačítka myši a pozice myši uvnitř okna jsou vypisovány na systémové konzole.
Program lze ukončit stiskem klávesy Escape. Klávesa T vypíše čas a počet rámců okna vykreslených za sekun-
du.
#include <stdio.h>
#include <stdlib.h>
#include <mgl.h>
void display (void)
{
mglClearScreen (mglBlack);
mglSetRectangleColors (mglCeleste);
mglDrawFilledRectangle (0, 0, mglVirtualWidth, mglVirtualHeight);
}
void keyboard (int key)
{
switch (key)
{
case 't':
case 'T':
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
92
-
printf ("mglTime is %02i:%02i:%02i\n", mglHours (mglTime),
mglMinutes(mglTime), mglSecs (mglTime));
printf ("mglSystemTime is %02i:%02i:%02i\n",
mglHours (mglSystemTime), mglMinutes (mglSystemTime),
mglSecs (mglSystemTime));
printf ("Frames per second: %6.2f\n", mglFps);
break;
case 27: // Escape
exit (0);
break;
default:
if (key < 256)
printf ("Typed character %c (ascii value %i)\n", key, key);
else
printf ("Pressed special key with value %i\n", key);
if (mglShift)
printf ("Shift key pressed.\n");
if (mglCtrl)
printf ("Ctrl key pressed.\n");
if (mglAlt)
printf ("Alt key pressed.\n");
}
}
void mouse (int event)
{
switch (event)
{
case MGL_LEFT_BUTTON_DOWN:
printf ("Left button pressed.\n");
break;
case MGL_LEFT_BUTTON_UP:
printf ("Left button released.\n");
break;
case MGL_RIGHT_BUTTON_DOWN:
printf ("Right button pressed.\n");
break;
case MGL_RIGHT_BUTTON_UP:
printf ("Right button released.\n");
break;
}
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
93
-
if (mglMouseIn)
{
printf ("Mouse is located inside the window on position (%i,%i)\n",
mglMouseX, mglMouseY);
}
else
printf ("Mouse is not located in the window.\n");
}
int main (void)
{
mglVirtualWidth = mglVirtualHeight = 1000;
mglOpenWindow ("Demonstrace modulu Input", 100, 100, 256, 128);
mglSetDisplayHandler (display);
mglSetKeyboardHandler (keyboard);
mglSetMouseHandler (mouse);
mglSetMouseCursor (MGL_CURSOR_CROSSHAIR);
mglRun ();
return 0;
}
13.2.8
Modul Errors
Modul zajišťuje ošetření chyb, vzniklých nesprávným použitím funkcí knihovny MGL, nedostatkem paměti,
selháním operačního systému, ovladače OpenGL a dalšími.
typedef void (*mglErrorHandlerType) (int errorNumber, char *errorMessage);
extern void mglSetErrorHandler (mglErrorHandlerType errorHandler);
Funkce nastaví uživatelem definovanou funkci danou parametrem
errorHandler
, která je volána při vzniku
chyby. Parametr
errorNumber
obsahuje kód chyby. Parametr
errorMessage
obsahuje řetězec popisující
vzniklou chybu. Po návratu z funkce dané parametrem
errorHandler
je aplikace ukončena voláním stan-
dardní funkce knihovny ANSI C
exit
.
extern void mglDefaultErrorHandler (int errorNumber, char *errorMessage);
Pokud nebyla nastavena uživatelem definovaná funkce pro ošetření chyb, je zavolána tato implicitně nastavená
funkce. Ta na systémech Windows zobrazí dialogový box s kódem a popisem chyby. Na ostatních systémech
jsou tyto údaje vypsány na konzole..
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
94
-
extern void mglError (int errorNumber, char *errorMessage);
Tato funkce je používána k vygenerování chyby dané číslem chyby
errorNumber
a řetězcem popisujícím
chybu daným parametrem
errorMessage
. Tato funkce je používaná rutinami knihovny MGL.
extern char *mglErrorType;
Obsahuje textový popis posledně vzniklé chyby. Je-li například kód chyby
MGL_ERROR_UNKNOWN
, obsahuje
řetězec
„MGL_ERROR_UNKNOWN“
.
extern void mglMessage (char *title, char *message);
Na systémech Windows zobrazí dialogové okno s titulkem daným parametrem
title
. Uvnitř okna potom zob-
razí zprávu danou parametrem
message
. Na ostatních systémech zobrazí zprávu danou parametrem
message
na konzoli.
13.2.8.1
Kódy chyb
MGL_ERROR_UNKNOWN
Neznámá chyba.
MGL_ERROR_COMPILER_OPTIONS
Knihovna MGL nebyla zkompilována požadovaným 32-bitovým překladačem. Je nutné změnit parametry pře-
kladu, případně použít jiný překladač.
MGL_ERROR_NOT_ENOUGH_MEMORY
Nedostatek paměti pro alokaci datových struktur knihovny MGL.
MGL_ERRORS_OPENGL_CALLS
Při volání funkcí knihovny OpenGL došlo k chybě.
MGL_ERROR_USER
Uživatelem vygenerovaná chyba.
MGL_ERROR_NO_OPENGL_DRIVERS
V použitém systému nebyly nalezeny ovladače OpenGL.
MGL_ERROR_NO_GLU_DRIVERS
V systému nebyly nalezeny ovladače knihovny GLU. GLU je součástí jádra OpenGL.
MGL_ERROR_UNKNOWN_OPENGL_VERSION
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
95
-
Implementace OpenGL má nesprávně vyplněnou řetězec obsahující verzi OpenGL, takže nebylo možné zjistit
číslo implementace.
MGL_ERROR_SUBTEXTURE_COORDINATES
Souřadnice zobrazovaného výřezu textury jsou neplatné.
MGL_ERROR_UNKNOWN_TEXTURE_MODE
Funkci
mglMakeTexture
b
yl předán neplatný parametr režimu zpracování textur.
MGL_ERROR_TOO_BIG_TEXTURE
Pokus o práci s texturou, která je větší než je podporováno použitou implementací OpenGL.
MGL_ERROR_TEXTURE_SIZE
Délka i šířka textury musí být mocninou dvou.
MGL_ERROR_MISSING_MIPMAP
Byl zadán neúplný soubor mipmap při vytváření textury pomocí funkce
mglMakeTexture
.
MGL_ERROR_OPENING_FILE
Chyba při otevírání souboru. Soubor pravděpodobně nebyl v systému nalezen.
MGL_ERROR_CREATING_FILE
Chyba při vytváření nového souboru.
MGL_ERROR_WRITING_FILE
Chyba při zápisu do souboru.
MGL_ERROR_READING_IMAGE_DATA
Chyba při čtení dat z obrazového souboru. Soubor je pravděpodobně poškozený.
MGL_ERROR_READING_TGA_HEADER
Chyba při čtení hlavičky souboru TGA. Soubor je pravděpodobně poškozený.
MGL_ERROR_READING_BMP_HEADER
Chyba při čtení hlavičky souboru BMP. Soubor je pravděpodobně poškozený.
MGL_ERROR_READING_TGA_HEADER
Chyba při čtení hlavičky souboru TGA. Soubor je pravděpodobně poškozený.
MGL_ERROR_UNSUPPORTED_IMAGE
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
96
-
Formát souboru není podporován knihovnou MGL. Knihovna MGL podporuje formáty .BMP, .TGA, .SGI, a
.BW.
MGL_ERROR_UNSUPPORTED_TGA_IMAGE
Soubor není platný obrazový soubor formátu TGA podporovaný knihovnou MGL.
MGL_ERROR_UNSUPPORTED_BMP_IMAGE
Soubor není platný obrazový soubor formátu BMP podporovaný knihovnou MGL.
MGL_ERROR_UNSUPPORTED_SGI_IMAGE
Soubor není platný obrazový soubor formátu SGI podporovaný knihovnou MGL.
MGL_ERROR_FONT_DEFINITION_FILE
Chyba při čtení souboru, obsahujícího definice, souřadnice a velikosti písmen fontů.
13.2.8.2
Příklad
Následující příklad nastaví obsluhu chyb, které mohou vzniknout při běhu knihovny MGL. Poté je otevřen nee-
xistující soubor, který přinutí knihovnu MGL k vygenerování chyby. Při vzniku chyby je zobrazeno dialogové
okno na následujícím obrázku.
#include <stdio.h>
#include <mgl.h>
void myErrorHandler (int type, char *errorStr)
{
char s [333];
sprintf (s, "Number : %i\n"
"Type : %s\n"
"Description : %s\n", type, mglErrorType, errorStr);
mglMessage ("Error detected", s);
}
int main (void)
{
mglOpenWindow ("Demonstrace modulu Errors", 100, 100, 256, 256);
mglSetErrorHandler (myErrorHandler);
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
97
-
mglLoadImage ("this_file_surely_does_not_exists.image", 0);
return 0;
}
Obrázek 41 – Dialogové okno oznamující výskyt chyby
13.2.9
Modul Memory
Funkce modulu memory nejsou dokumentovány. Modul je určen pouze pro interní použití knihovnou MGL, pro
alokaci a uvolňování paměťových struktur.
13.3
Výpisy vybraných zdrojových souborů a částí kódu
V této podkapitole jsou vypsány soubory zdrojových kódů, na které je odkazováno v předchozích kapitolách
diplomové práce.
13.3.1
Výpis souboru alpha.c
/*
* alpha.c
* This program draws several overlapping filled polygons
* to demonstrate the effect order has on Alpha Blending results.
* Use the 't' key to toggle the order of drawing polygons.
*/
#include <GL/glut.h>
#include <stdlib.h>
static int leftFirst = GL_TRUE;
/* Initialize Alpha Blending function.
*/
static void init(void)
{
glEnable (GL_BLEND);
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
98
-
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glShadeModel (GL_FLAT);
glClearColor (0.0, 0.0, 0.0, 0.0);
}
static void drawLeftTriangle(void)
{
/* draw yellow triangle on LHS of screen */
glBegin (GL_TRIANGLES);
glColor4f(1.0, 1.0, 0.0, 0.75);
glVertex3f(0.1, 0.9, 0.0);
glVertex3f(0.1, 0.1, 0.0);
glVertex3f(0.7, 0.5, 0.0);
glEnd();
}
static void drawRightTriangle(void)
{
/* draw cyan triangle on RHS of screen */
glBegin (GL_TRIANGLES);
glColor4f(0.0, 1.0, 1.0, 0.75);
glVertex3f(0.9, 0.9, 0.0);
glVertex3f(0.3, 0.5, 0.0);
glVertex3f(0.9, 0.1, 0.0);
glEnd();
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
if (leftFirst) {
drawLeftTriangle();
drawRightTriangle();
}
else {
drawRightTriangle();
drawLeftTriangle();
}
Programová rozhraní pro grafické adaptéry
Doporučené stránky
-
99
-
glFlush();
}
void reshape(int w, int h)
{
glViewport(0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (w <= h)
gluOrtho2D (0.0, 1.0, 0.0, 1.0*(GLfloat)h/(GLfloat)w);
else
gluOrtho2D (0.0, 1.0*(GLfloat)w/(GLfloat)h, 0.0, 1.0);
}
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 't':
case 'T':
leftFirst = !leftFirst;
glutPostRedisplay();
break;
case 27: /* Escape key */
exit(0);
break;
default:
break;
}
}
/* Main Loop
* Open window with initial window size, title bar,
* RGBA display mode, and handle input events.
*/
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (200, 200);
glutCreateWindow (argv[0]);
Programová rozhraní pro grafické adaptéry
Doporučené stránky
- 100 -
init();
glutReshapeFunc (reshape);
glutKeyboardFunc (keyboard);
glutDisplayFunc (display);
glutMainLoop();
return 0;
}
13.3.2
Výpis souboru alpha_m.c
#include <mgl.h>
#include <stdlib.h>
int leftFirst;
void display_mgl (void)
{
mglColor leftColor = {1.0, 1.0, 0.0, 0.75};
mglColor rightColor = {0.0, 1.0, 1.0, 0.75};
mglClearScreen (mglBlack);
if (leftFirst)
{
mglSetTriangleColors (rightColor);
mglDrawFilledTriangle (100, 900, 100, 100, 700, 500);
mglSetTriangleColors (leftColor);
mglDrawFilledTriangle (900, 900, 300, 500, 900, 100);
}
else
{
mglSetTriangleColors (leftColor);
mglDrawFilledTriangle (900, 900, 300, 500, 900, 100);
mglSetTriangleColors (rightColor);
mglDrawFilledTriangle (100, 900, 100, 100, 700, 500);
}
}
void keyboard_mgl (int key)
{
Programová rozhraní pro grafické adaptéry
Doporučené stránky
- 101 -
switch (key)
{
case 't':
case 'T':
leftFirst = !leftFirst;
break;
case 27: /* Escape key */
exit(0);
break;
default:
break;
}
}
int main (int argc, char **argv)
{
mglVirtualWidth = mglVirtualHeight = 1000;
mglOpenWindow (argv [0], 100, 100, 200, 200);
mglSetKeyboardHandler (keyboard_mgl);
mglSetDisplayHandler (display_mgl);
mglRun ();
return 0;
}
13.3.3
Výpis programu checker.c
/* checker.c
* This program texture maps a checkerboard image onto
* two rectangles.
*
* If running this program on OpenGL 1.0, texture objects are
* not used.
*/
#include <GL/glut.h>
#include <stdlib.h>
#include <stdio.h>
/* Create checkerboard texture */
Programová rozhraní pro grafické adaptéry
Doporučené stránky
- 102 -
#define checkImageWidth
64
#define checkImageHeight
64
static GLubyte checkImage[checkImageHeight][checkImageWidth][4];
#ifdef GL_VERSION_1_1
static GLuint texName;
#endif
void makeCheckImage(void)
{
int i, j, c;
for (i = 0; i < checkImageHeight; i++) {
for (j = 0; j < checkImageWidth; j++) {
c = ((((i&0x8)==0)^((j&0x8))==0))*255;
checkImage[i][j][0] = (GLubyte) c;
checkImage[i][j][1] = (GLubyte) c;
checkImage[i][j][2] = (GLubyte) c;
checkImage[i][j][3] = (GLubyte) 255;
}
}
}
void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel(GL_FLAT);
glEnable(GL_DEPTH_TEST);
makeCheckImage();
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
#ifdef GL_VERSION_1_1
glGenTextures(1, &texName);
glBindTexture(GL_TEXTURE_2D, texName);
#endif
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
Programová rozhraní pro grafické adaptéry
Doporučené stránky
- 103 -
#ifdef GL_VERSION_1_1
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, checkImageWidth,
checkImageHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, checkImage);
#else
glTexImage2D(GL_TEXTURE_2D, 0, 4, checkImageWidth,
checkImageHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, checkImage);
#endif
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_TEXTURE_2D);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
#ifdef GL_VERSION_1_1
glBindTexture(GL_TEXTURE_2D, texName);
#endif
glBegin(GL_QUADS);
glTexCoord2f(0.0, 0.0); glVertex3f(-2.0, -1.0, 0.0);
glTexCoord2f(0.0, 1.0); glVertex3f(-2.0, 1.0, 0.0);
glTexCoord2f(1.0, 1.0); glVertex3f(0.0, 1.0, 0.0);
glTexCoord2f(1.0, 0.0); glVertex3f(0.0, -1.0, 0.0);
glTexCoord2f(0.0, 0.0); glVertex3f(1.0, -1.0, 0.0);
glTexCoord2f(0.0, 1.0); glVertex3f(1.0, 1.0, 0.0);
glTexCoord2f(1.0, 1.0); glVertex3f(2.41421, 1.0, -1.41421);
glTexCoord2f(1.0, 0.0); glVertex3f(2.41421, -1.0, -1.41421);
glEnd();
glFlush();
glDisable(GL_TEXTURE_2D);
}
void reshape(int w, int h)
{
glViewport(0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0, (GLfloat) w/(GLfloat) h, 1.0, 30.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
Programová rozhraní pro grafické adaptéry
Doporučené stránky
- 104 -
glTranslatef(0.0, 0.0, -3.6);
}
void keyboard (unsigned char key, int x, int y)
{
switch (key) {
case 27:
exit(0);
break;
default:
break;
}
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(250, 250);
glutInitWindowPosition(100, 100);
glutCreateWindow(argv[0]);
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}
13.3.4
Výpis programu checkr_m.c
#include <mgl.h>
#include <stdlib.h>
#include <stdio.h>
mglTexture *chessTexture;
void display_mgl (void)
{
mglBegin ();
Programová rozhraní pro grafické adaptéry
Doporučené stránky
- 105 -
mglClearScreen (mglBlack);
mglSetTextureZoom (8);
mglDrawTexture (chessTexture, 25, 250);
mglEnd ();
glEnable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0, 1.0, 1.0, 30.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0.0, 0.0, -3.6);
mglChangeTexture (chessTexture);
glEnable (GL_TEXTURE_2D);
glBegin(GL_QUADS);
glTexCoord2f(0.0, 0.0); glVertex3f(1.0, -1.0, 0.0);
glTexCoord2f(0.0, 1.0); glVertex3f(1.0, 1.0, 0.0);
glTexCoord2f(1.0, 1.0); glVertex3f(2.41421, 1.0, -1.41421);
glTexCoord2f(1.0, 0.0); glVertex3f(2.41421, -1.0, -1.41421);
glEnd();
}
void keyboard_mgl (int key)
{
switch (key) {
case 27:
exit(0);
break;
default:
break;
}
}
int main(int argc, char** argv)
{
mglVirtualWidth = mglVirtualHeight = 1000;
mglOpenWindow (argv [0], 100, 100, 250, 250);
Programová rozhraní pro grafické adaptéry
Doporučené stránky
- 106 -
chessTexture = mglLoadTexture ("../data/examples/checker.tga", 0,
GL_NEAREST);
mglSetDisplayHandler (display_mgl);
mglSetKeyboardHandler (keyboard_mgl);
mglRun ();
return 0;
}
13.3.5
Fragmenty kódů srovnávacího příkladu tunnel
Fragment kódu vykreslující nápovědu pomocí volání GLUT a OpenGL je následující:
static void printstring(void *font, char *string)
{
int len,i;
len=(int)strlen(string);
for(i=0;i<len;i++)
glutBitmapCharacter(font,string[i]);
}
static void helpopengl (char *rate, char *about)
{
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glColor4f(0.0,0.0,0.0,0.5);
glRecti(40,40,600,440);
glDisable(GL_BLEND);
glColor3f(1.0,1.0,1.0);
glRasterPos2i(300,420);
printstring(GLUT_BITMAP_TIMES_ROMAN_24,"Help");
glRasterPos2i(60,390);
printstring(GLUT_BITMAP_TIMES_ROMAN_24,"h - Togle Help");
glRasterPos2i(60,360);
Programová rozhraní pro grafické adaptéry
Doporučené stránky
- 107 -
printstring(GLUT_BITMAP_TIMES_ROMAN_24,"t - Togle Textures");
glRasterPos2i(60,330);
printstring(GLUT_BITMAP_TIMES_ROMAN_24,"f - Togle Fog");
glRasterPos2i(60,300);
printstring(GLUT_BITMAP_TIMES_ROMAN_24,"m - Togle strips");
glRasterPos2i(60,270);
printstring(GLUT_BITMAP_TIMES_ROMAN_24,"b - Togle Back face culling");
glRasterPos2i(60,240);
printstring(GLUT_BITMAP_TIMES_ROMAN_24,"Arrow Keys - Rotate");
glRasterPos2i(60,210);
printstring(GLUT_BITMAP_TIMES_ROMAN_24,"a - Increase velocity");
glRasterPos2i(60,180);
printstring(GLUT_BITMAP_TIMES_ROMAN_24,"z - Decrease velocity");
glRasterPos2i(60,150);
if(joyavailable)
printstring(GLUT_BITMAP_TIMES_ROMAN_24,"j - Togle jostick control
(Joystick control available)");
else
printstring(GLUT_BITMAP_TIMES_ROMAN_24,"(No Joystick control availa-
ble)");
glColor3f(1.0,0.0,0.0);
glRasterPos2i(10,10);
printstring(GLUT_BITMAP_HELVETICA_18,rate);
glRasterPos2i(300,470);
printstring(GLUT_BITMAP_HELVETICA_10,about);
}
Fragment kódu vykreslující nápovědu pomocí volání funkcí MGL je následující:
static void helpmgl (char *rate, char *about)
{
mglColor c;
mglBegin ();
c = mglBlack;
c.a = 0.5;
mglSetRectangleColors (c);
mglDrawFilledRectangle (40, 40, 560, 400);
Programová rozhraní pro grafické adaptéry
Doporučené stránky
- 108 -
mglSetTextureColors (mglBlue);
mglSetTextureZoom (0.5333);
mglPuts (font, about, 133, 10);
mglSetTextureZoom (0.7);
mglPuts (font, rate, 10, 450);
mglSetTextureZoom (1);
mglSetTextureColors (mglWhite);
mglPuts (font, "MGL Help", 300, 60);
mglPuts (font, "h - Togle Help", 60, 90);
mglPuts (font, "t - Togle Textures", 60, 120);
mglPuts (font, "f - Togle Fog", 60, 150);
mglPuts (font, "m - Togle strips", 60, 180);
mglPuts (font, "b - Togle Back face culling", 60, 210);
mglPuts (font, "Arrow Keys - Rotate", 60, 240);
mglPuts (font, "a - Increase velocity", 60, 270);
mglPuts (font, "z - Decrease velocity", 60, 300);
if(joyavailable)
mglPuts (font, "j - Togle jostick control (Joystick control availa-
ble)", 60, 330);
else
mglPuts (font, "(No Joystick control available)", 60, 330);
mglEnd ();
