Szegedi Tudományegyetem Informatikai Tanszékcsoport SZAKDOLGOZAT. Vadász László

Átírás

1 Szegedi Tudományegyetem Informatikai Tanszékcsoport SZAKDOLGOZAT Vadász László 2011

2 Szegedi Tudományegyetem Informatikai Tanszékcsoport 3D-s játék motor fejlesztése PyGL-ben Szakdolgozat Készítette: Vadász László informatika szakos hallgató Témavezető: Nagy Antal egyetemi adjunktus Szeged 2011

3 Feladatkiírás A feladatom egy olyan többplatformos (Linux, Windows) 3D-s motor fejlesztése Python [1] nyelven, mely az OpenGL [2] grafikus függvénykönyvtárat és a Qt [3] felhasználói interfészt használ. A motor egy egyszerű felületet biztosít többek között modellek betöltéséhez, textúrázáshoz, grafikusobjektumok manipulálásához, szövegek megjelenítéséhez és részecskerendszerekhez létrehozásához. A projekthez szorosan hozzá tartozik egy demó program is, amely bemutatja a motor képességeit. i

4 Tartalmi-összefoglaló A téma megnevezése: OpenGL alapú 3D-s játék fejlesztői felület Python nyelven. A megadott feladat megfogalmazása: A cél egy általánosan és könnyen használható, platformfüggetlen grafikus könyvár létrehozása volt, mely a megjelenítésen felül számos egyéb szolgáltatást is biztosít egy komplex alkalmazás összeállításához. A megoldási mód: A motor a Python, OpenGL Qt és numpy programkönyvtárakra épül. A rendszer ezek segítségével valósítja meg a szükséges adatok beolvasását, a matematikai műveletek elvégzését és 3D-s leképezést. Mindezt úgy, hogy a programozó számára egy egységes felületet biztosít. Alkalmazott eszközök, módszerek: Elsődlegesen nyílforrású eszközöket alkalmaztam a program megírása során: Python, OpenGL, Qt, numpy, Linux, NetBeans, Subversion, Epydoc, Gimp, Dia, OppenOffice, egyetlen kivétel a 3D Studio Max. A rendszer teljes mértékben objektumorientált, mely a rendszer tervezését is alapvetően meghatározta. Elért eredmények: A rendszer támogatja a legfontosabb 3D funkciókat, mint például a modellek betöltését, azok textúrázását és transzformálását, valamint magába foglalja az objektumok hierarchiájának kezelését, alapvető bevilágítást és szövegkezelést. Ezenfelül támogatja az eseményvezérlést és a beviteli eszközök kezelését. Kulcsszavak: API, Platformfüggetlenség, Python, OpenGL, Qt, Eseményvezérlés ii

5 Tartalomjegyzék Feladatkiírás...i Tartalmi-összefoglaló...ii Tartalomjegyzék...iii Bevezetés...2 I. Felhasznált eszközök Programozási nyelv és programkönyvtárak Python OpenGL (PyOpenGL) Qt (PyQt) numpy Fejlesztőkörnyezet Ubuntu, Linux NetBeans IDE Egyéb eszközök Subversion Epydoc ds Max Gimp Dia OpenOffice Writer...10 II. Az Ilo felépítése Adatszerkezetek és adattípusok A Python beépített típusai OpenGL típusok numpy típusok Vektorok (Vector modul) Kvaterniók (Quanternion modul) Mátrixok (Matrix modul) Modellekkel kapcsolatos struktúrák (d3d modul) Grafikus mag Singleton osztályok Gfx osztály GfxContext és GLContext osztályok GfxMatrix osztály Viewport osztály Fájlkezelés Konfigurációs fájl Osztálymetódusok a Python-ban Anyagjellemző kollekciók Színtér leíró fájl...28 iii

6 3.5. ModelFile osztály Modell leíró fájl ASE fájl Eseményvezérlés és felhasználói interakciók Qt eseménykezelő EventDispatcher osztály Eseményobjektumok Belső események Felhasználói interakciók Egyedi esemény osztályok Anyagjellemzők Material osztály Texture osztály Shader osztály Anyagjellemzők kezelése Grafikus elemek Mesh osztály Geometriák kezelése Leképezőobjektum RenderObject osztály RenderObjectContainer osztály RenderScene osztály Fények kezelése LightLibrary osztály LightObject osztály Szöveg megjelenítése Szövegleképezés Text osztály TextLine osztály Részecskerendszerek BaseParticleSystem osztály Az Ilo motor Az API telepítése Hardveres feltételek Ubuntu Linux rendszerre Windows 7 rendszerre...60 III. Bemutatóprogram A bemutatóprogram felépítése Fájlszerkezet A bemutatóprogram logikája Sajátosságok Képek a bemutató programból...66 IV. Irodalomjegyzék...67 V. Köszönetnyilvánítás...68 VI. Nyilatkozat...69 iv

7 Bevezetés A feladatom két részből tevődött össze. Az első részben az Ilo nevű 3D-s játékmotort készítettem el, mely a Python nyelven és az OpenGL grafikus rendszerre épül. A függvénykönyvtár bemutatására egy demó programot is létrehoztam, valamint részletesen dokumentációval is elláttam az egész kódbázist. A projektem az afrikai eredetű Ilo (fény, örömteli) nevet adtam. A célom az volt, hogy egy könnyen használható felület biztosítsak 3D-s alkalmazások fejlesztéséhez. Ezt a felületet 3D engine -nek is szokás nevezni. Az engine (motor) lényegében egy API, azaz Application Programming Interface. Egy olyan programkód gyűjtemény, mely nem egy önálló programként amit futtathatunk. Sokkal inkább egy eszköz más programok megírásához. Az API fő célja egy vagy több programozói felület egybefoglalása oly módon, hogy az leegyszerűsítse és megkönnyítse a fejlesztő dolgát úgy, hogy a legalapvetőbb funkciókra kész eszközöket ad a programozók kezébe. Az Ilo több programozói felületet integrál önmagába, többek között ezért nevezhetjük egy alkalmazás motorjának. Képes ellátni minden alapvető feladatot, amely egy 3D-s környezet felépítéséhez és manipulálásához szükséges. Ilyen funkciók például az ablakok kezelése, a leképező rendszer inicializálása és vezérlése, a grafikus objektumok tárolása, manipulálása és megjelenítése. Tovább számos egyéb kényelmi szolgáltatást is biztosít, amelyek szükség esetén igénybe vehetők. Ide lehet sorolni a 3D-s fájlformátumok kezelését vagy az eseményvezérlő modult. Az API teljes mértékben objektumorientált paradigmák szerint lett megtervezve és implementálva. A leírás során több ponton is kitérek a felhasznált technikákra és az alkalmazott programtervezési mintákra. A motor több más rendszerben már sikeresen használt ötletet is megvalósít. Az egyik ilyen ötlet az Adobe ActionScript 3.0 [4]-ban alkalmazott objektum hierarchia és eseményvezérlő rendszer, mely egyszerűsége ellenére igen hatékony megoldást nyújt. A másik meghatározó példát a Drome Engine [5] nevű 3D-s motor szolgáltatta, melyet Josh Beam írt C++ nyelven. Nagymértékben hozzájárult az Ilo grafi- 2

8 Bevezetés kus magjának végső formájához, illetve a Quanternion és a Camera) osztályok megvalósításához. A dolgozat első részében a projekt fejlesztése során felhasznált eszközöket vesszük sorra és megvizsgáljuk a feladat szempontjából fontos tulajdonságaikat. Ezt követően az API felépítését és egyes részegységeit tekintjük át, modulról modulra. Eközben megismerkedünk a beépített függvénykönyvtárakkal és felhasznált programozási technikákkal. Végül szemügyre vesszük az Ilo motor felhasználásával készült be mutatóprogramot. A könnyebb érthetőség érdekében (ahol csak lehetett) a leírás mellett szerepleni fog a probléma megoldásának pszeudokódja is, amely a Python nyelvtanára épül. Például: class A(object): def func(a,b,c): if True: for i in [1,2,3]: glxxx() pass # Ez egy megjegyzés # object osztály származtatása # Függvény / metódus definíció # Feltételes elágazás # Lista bejárása For ciklussal # XXX OpenGL függvény hívás # Üres utasítás 3

9 I. Felhasznált eszközök A fejlesztés során arra törekedtem, hogy lehetőleg csak nyílt forrású és szabadon felhasználható eszközöket alkalmazzak. Meglátásom szerint nem csak a kereskedelmi szofverekkel nyújthatnak megfelelő minőséget, sőt! Sokszor inkább a nyílt rendszerek bizonyulnak használhatóbbnak és megbízhatóbbnak. Továbbá rengeteg leírás érhető el az interneten keresztül ezekhez a szofverekhez. Nem csak az alkalmazás dokumentációját, de általában egy-egy probléma megoldását is megtalálhatjuk a program weboldalán (pl.: NetBeans) vagy a hozzá kapcsolódó közösségi fórumon. A fejlesztés közben csak egy olyan programot alkalmaztam, amely nem érhető el ingyenesen. Nagyon fontosnak tartom, hogy egy adott problémához a legmegfelelőbb eszközt használjuk, amelyet lehetőleg még a projekt előkészületei során válasszunk ki. A fejlesztés alatt számos alkalmazást és segédprogramot használtam fel, melyeket a következő alfejezetekben részletesen is bemutatok. Nem a programok jó és rossz tulajdonságait szeretném kihangsúlyozni, hanem inkább azt, hogy miért pont ezekre esett a választásom és miért voltak számomra ezek a legmegfelelőbbek a projekt elkészítéséhez. 1. Programozási nyelv és programkönyvtárak A nyelv és a programkönyvtárak kiválasztása a legfontosabb lépés, hiszen ezek nagymértékben befolyásolhatják a rendszer képességeit, arról nem is beszélve, hogy egy rossz választás kihat az egész fejlesztési folyamatra. Minden nyelvnek vannak gyenge és erős pontja. Az a legoptimálisabb ha a kiválasztott környezet, nem csak megfelelő nyelvi támogatást nyújt a céljaink eléréséhez, de rendelkezik bőséges és jó programkönyvtárakkal. A következő fejezetekben megismerkedhetünk az Ilo fejlesztése során alkalmazott nyelvvel és az ahhoz kapcsolódó programkönyvtárakkal, ezeken belül is a rendszer számára nélkülözhetetlen elemekkel. 4

10 Felhasznált eszközök 1.1. Python A Pythont egy bizonyos Guido van Rossum nevű holland programozó alkotta meg 1991-ben. A nyelv kifejlesztésekor az egyszerű szintaxis, a jól olvasható forráskód és a fejlesztés megkönnyítése volt az elsődleges cél. A Python egy interpretált nyelv, tehát a forráskód nem esik át tényleges fordításon. Az értelmező (Python interpreter) a futtatás során előbb feldolgozza az aktuális forrásfájlt (a forrás bytekódra fordítja), majd utasításról utasításra végrehajtja a programot. A Python három programozási paradigmát is támogat, melyeket akár egyszerre is alkalmazhatunk programunkban. Tetszőlegesen használhatjuk a funkcionális vagy az objektum-orientált paradigmákat. Az értelmező dinamikusan kezeli a változókat és azok típusait, melyeknek létrehozását és felszabadítását is teljesen automatikusan végzi. Azért döntöttem a Python mellett, mert kényelmesen és gyorsan lehet benne programozni. Az interaktív értelmezőnek köszönhetően könnyedén kipróbálhatóak és tesztelhetők az egyszerűbb komponensek, még mielőtt beépítésre kerülnének. Továbbá a Python támogatja az össze fontosabb platformot, így a portolásra (a motor egy másik rendszerre történő átírására) jóval kevesebb időt kellett fordítani. A fejlesztés során a Python [1] es verzióját használtam. A motor szempontjából viszont a sebesség is nagyon fontos kritérium. Ehhez a nyelv egy másik előnyös tulajdonságát használtam fel: a Python képes más nyelven írt függvénykönyvtárak importálására, oly módon, hogy az adott könyvtárat egy belső Python modulba csomagolják (wrappelik) és ezen keresztül érhetjük el annak függvényeit és objektumait. Ezzel a módszerrel készítették el az általam is használt PyOpenGL és PyQt modulokat is, melyek eredetileg C és C++ nyelven íródtak, de a becsomagoláson keresztül már Python-ból is használhatók az ezekben található modulok. Így a programkód jó része natív módon hajtódik végre, ezáltal jelentős sebesség növekedést érhetünk el OpenGL (PyOpenGL) Az OpenGL [2] (Open Graphics Library) a Silicon Graphics nevű amerikai cég által 1992-ben kifejlesztett grafikuskönyvtár, mely 2 és 3 dimenziós objektumok számítógépes 5

11 Felhasznált eszközök leképezéséhez nyújt egy igen bőséges függvénykönyvtárat. Nyíltsága, egyszerűsége, gyorsasága és kliens-szerver felépítése miatt igen hamar elterjedt és mára már minden grafikus lapkakészlet és operációs rendszer támogatja. Két fő oka is volt, hogy az OpenGL mellett döntöttem. Az egyik, hogy tanulmányaim során többször is szükség volt a használatára és igen megkedveltem a használatát. A másik pedig a platformfüggetlenség. Az OpenGL a PyOpenGL modulon keresztül kapcsolódik a Pythonhoz. A PyOpenGL a C alapú OpenGL könyvtár egy Python-os becsomagolása, mely segítségével elérhetővé válnak a grafikusfüggvények. Ráadásul ezeket is a Python-ban már megszokott egyszerűséggel használhatjuk (például: változó típusok kezelése). A PyOpenGL az alap OpenGL függvényeken felül tartalmazza a GLU és GLUT kiegészítőkönyvtárakat is. A fejlesztés során a PyOpenGL [6] es verzióját használtam Qt (PyQt) A Qt [3] egy igen elterjedt és nagyon jól használható grafikus felhasználói felületrendszer (GUI Framework), melyet C++-ban implementáltak és támogatja az összes fontosabb platformot. Sok kereskedelmi (pl.: Google Earth) és nyílt forrású (pl.: KDE) projekt alapját ez a framework képezi. Elsősorban a hordozhatósága és a letisztultsága miatt döntöttem a Qt mellett, melyet PyQt néven találhatunk meg a Python modulok között. Robusztusságának köszönhetően ugyanúgy alkalmazható az Ilo-hoz, hasonló kisebb projektekhez, mint komoly, nagy rendszerekhez. Egy másik nagy előnye, hogy nagy mértékben támogatja az OpenGL alapú leképezést, ami megkönnyítette az Ilo-ba integrálását. A fejlesztés során a PyQt [7] 4.6-os verzióját használtam numpy A numpy egy nagy tudású numerikus könyvtár, mely főbb erőssége a több dimenziós tömbökkel való műveletvégzés és a lineáris algebrában alkalmazott számítások elvégzése. A PyOpenGL is ezt a modult használja a vektor- és mátrixműveletek kiszámítására, így kézenfekvő volt, hogy ezt a könyvtárat használjam a rendszer fejlesztése során. 6

12 Felhasznált eszközök Ezzel nem csak a belső vektor- és mátrixosztályok létrehozása vált könnyebbé, de az OpenGL modullal is jobban együtt tud működni az API-val. A numpy-t ezen kívül más egyéb területken is alkalmazzák. A grafikai számításokhoz szükséges eljárásokon kívül számos más művelet elvégzésére is alkalmas. Jelölés rendszere és az objektumok elnevezései, sőt bizonyos mértékig (a Python határain belül) a szintaktikája is a MatLab nevű programozási nyelvre hasonlít. A fejlesztés során a numpy [8] s verzióját használtam. 2. Fejlesztőkörnyezet A nyelv és a hozzákapcsolódó könyvtárak (library) kiválasztása után a következő fontos lépés a fejlesztőkörnyezet kialakítása. Több okból sem szabad elhamarkodottan dönteni. Egyrészt fontos, hogy a választott eszközök illeszkedjenek és támogassák a használni kívánt programozási nyelvet, másrészről pedig kézreállónak és jól használhatónak kell lenniük. A két legfontosabb eszközünk az integrált fejlesztői környezet és maga az Operációs rendszer Ubuntu, Linux Operációs rendszernek a nyílt forrású Ubuntu-t választottam. Egy gyors, letisztult és megbízható rendszernek ismertem meg az évek során. A fejlesztés során az Ubuntu egy kiváló fejlesztői platformnak bizonyult. Számos olyan programot biztosít, melyek megkönnyítik a munkát. Az Ubuntu-t körülvevő hatalmas közösségnek, a jó támogatottságnak és a bőséges leírásoknak köszönhetően a felmerülő problémákra szinte azonnal megtaláltam a megoldást. A Linux alapvetően nem számít játék platformnak. Azonban ma már adottak az OpenGL-t támogató és megfelelő minőségű meghajtóprogramok, így nem okoz problémát a 3D-s leképezés ezen a platformon sem. Így a megfelelő függőségek telepítését követően minden tökéletesen működik, sőt a sebesség is elfogadható. Az Ubuntuval szállított meghajtó programok megfelelő teljesítményt nyújtanak az Ilo futtatásához, amennyiben a hardveres követelményeknek teljesülnek. A fejlesztés során az Ubuntu 9.10-es (Karmic Koala) [9] verzióját használtam. 7

13 Felhasznált eszközök 2.2. NetBeans IDE A NetBeans a Sun (Oracle) által fejlesztett ingyenesen letölthető IDE (Integrated Development Environment Integrált Fejlesztői Környezet), melyet alapvetően Java és a a Java-hoz kötődő rendszerek fejlesztésére hoztak létre. Ennek ellenére egy ideje a Python-hoz is komoly eszközkészletet biztosítanak, ilyen eszköz például a forráskód elemeinek kiemelés, a kódkiegészítés, a szintaxis ellenőrzés, a beépített konzol és a debug funkciók. A letisztult kezelőfelület sok szempontból megkönynyítette a munkát, akár csak a beépülő plugin-ek melyek tovább növelték a rendszer hatékonyságát. A fejlesztés során végig megbízhatóan és stabilan működött. Negatívumként talán csak a nagy memóriaigényt, a lassú indulást és a még mindig fejlesztés alatt álló Python nyelvi bővítmény hiányosságai említhetők meg. De ezek csak kis mértékben voltak zavaróak. A fejlesztés során a NetBeans IDE [10] 6.8-as verzióját használtam. 3. Egyéb eszközök Ebben az alfejezetben azokat a programokat vesszük sorra, melyek csak közvetve kapcsolódnak a projekt létrehozásához. Ezek nélkül is elkészülhetett volna az Ilo. Azonban a forráskód tárolásához, demó program elkészítéséhez valamint a dolgozat megírásához még is nélkülözhetetlen eszközök voltak Subversion A forrásfájlok megfelelő tárolására az Apache által kifejlesztett nyílforrású verziókövető-rendszert, a subversion-t (SVN) használtam. Az SVN bővítmény formájában a Net- Beans-en keresztül is használható. Segítségével biztonságosan és hatékonyan tárolhattam a forrásfájlokat. Szükségesetén bármely korábbi verzióhoz (revision) visszatérhettem vagy összehasonlíthattam az aktuális állapottal. Továbbá a változások is jobban nyomon követhetővé váltak. A projektet a Google Code tárolójában (repository) helyeztem el, GNU GPLv2-es licenc alatt. Az SVN-be csak a karakteres forrásfájlok kerültek feltöltésre, a bináris jellegű állományok (pl.: bájtkód, stb.) nem. Ez alól egy-két textúra kivételt képez (pl.: fontmap), mert ezek nem változtak feltöltésről feltöltésre és szükségesek az API működéséhez. Minden feltöltés részletesen dokumentálva van, a könnyebb visszakövethető- 8

14 Felhasznált eszközök ség érdekében. A fejlesztés során a Subversion NetBenas bővítmény s verzióját használtam, mely az Apache Subversion [11] 1.6-os változatára épül 3.2. Epydoc Az Epydoc egy a Python-hoz kifejlesztett dokumentációkészítő-rendszer. A forráskód elemzésével és az egyes elemekhez (osztályok, metódusok, stb.) elhelyezett speciális, úgynevezett docstring -ek segítségével állítja össze a program dokumentációját (mint pl.: JavaDoc). A Python öndokumentáló, azaz minden modulhoz, osztályhoz és metódushoz megadhatunk egy szöveges leírást (docstring), ami bekerül a végleges rendszerbe és bármikor (futásközben is) lekérdezhető a help() függvény segítségével. Ezt a rövid leírást használja fel az Epydoc. A docstring-et elláthatjuk speciális jelölésekkel is, melyet az Epydoc értelmezője feldolgoz és ennek megfelelő generálja le a dokumentációt. Így nem csak esztétikailag (felsorolások, idézetek, linkek, stb.) lehet szebbé tenni, de sok plusz információt is elhelyezhetünk (pl.: típus információk, visszatérési értékek) a dokumentációban. Az Epydoc, alapvetően HTML dokumentumot generál, de képes PDF kimenet is létrehozni. A fejlesztés során az Epydoc [12] 3.0-s verzióját használtam ds Max A 3ds Max (korábbi nevén 3D Studio Max) egy modellező és animáció készítő szofver, melyet elsősorban játékprogramok objektumainak és mozgásanimációinak elkészítéséhez használnak. A felhasznált eszközök közül ez az egyetlen, amely nem érhető el ingyenesen (leszámítva a 30 napos próbaváltozatot). Azért a 3ds Max-et választottam, mert egyrészt hobbi szinten már korábban is használtam modellezésre és így hatékonyan tudtam vele dolgozni, másrészről csak ezzel lehet megfelelő ASE (Ascii Scene Exporter) formátumba elmenteni a már elkészült modelleket. Felmerült a Blender nevű nyílt modellező program használat is, de ez utóbbi feltétel miatt nem tudtam alkalmazni. A modellezésen felül az objektumok textúrázását is a 3ds Max-el segítségével csináltam meg. A modellek elkészítéséhez az Autodesk 3ds Max 2010 [13]-es programot használtam 9

15 Felhasznált eszközök 3.4. Gimp A demó programban található objektumok textúráit a nyílt forrású képszerkesztővel a Gimp-pel (GNU Image Manipulation Program) készítettem el. A szükséges képeket egy ingyenes textúra gyűjteményből (CG Texture [14]) töltöttem le, majd a Gimp segítségével méretre vágtam és összeillesztettem egy képpé azokat a darabokat, amelyek ugyan ahhoz a modellhez tartoztak. A textúrák elkészítéséhez a Gimp [ 15] es változatát használtam Dia A Dia egy szerkezeti diagram rajzoló alkalmazás, mellyel többek között kapcsolási rajzokat, folyamat ábrákat, és UML (Unified Modeling Language) ábrákat lehet készíteni. Az API átláthatósága kedvéért állítottam össze egy vázlatos osztálydiagramot. Az elkészült ábra nagy vonalakban tartalmazza a motor összes modulját, osztályát, valamint a köztük lévő kapcsolatokat. A diagramok elkészítéséhez a Dia [16] 0.97-es változatát használtam OpenOffice Writer Az OpenOffice [17] egy teljesen ingyenes irodai programcsomag, mely többek között a Writer szövegszerkesztőt is magába foglalja. A Writer egy általános célú szövegszerkesztő program, mely a rövid és hosszú kiadványok szerkesztésére egyaránt alkalmas. A sablonkezelő rendszerének köszönhetően egyszerűen és gyorsan össze állíthattam a dolgozat fő vázát, melynek így minden elem a megfelelő paraméterek beállításával egyszerűen módosítható. A Writernek széles eszközkészletet biztosít az egyszerű kiadvány készítéshez, mint például a stílusok alkalmazása, a tartalomjegyzék összeállítása vagy az irodalomjegyzék kezelése és létrehozás. Továbbá az elkészített dokumentumot minden fontosabb formátumban képes elmenteni, többek között Word doc-ban is. Sőt akár egyetlen kattintással PDF-be (Portable Document Format) is exportálhatom a kész szöveget, ezzel biztosítva annak hordozhatóságát. A dolgozat megírásához az OpenOffice Writer 3.2-es verzióját használtam. 10

16 II. Az Ilo felépítése Az Ilo számos modulból (Java terminológia szerint csomag vagy packege) épül fel, melyek mindegyik több osztályt tartalmaz. Python-ban (többek között a Java-tól eltérően) minden forrás fájl egy modulnak számít. Az Ilo-ban található modulok három fő csoportra bonthatók: Az első csoportba tartoznak az adatstruktúrákat megvalósító osztályok, amelyek nem függnek a rendszer többi moduljától. Viszont szinte minden adat ezekben a szerkezetekben van eltárolva. Éppen ezrét a többi modul aktívan használja ezeket. A másodikba a rendszerszintű modulok vannak, amelyek a felhasznált programkönyvtárakra (elsősorban az OpenGL) építkeznek. Ezek a modulok olyan osztályokat és metódusokat tartalmaznak, amelyek egyrészt leegyszerűsítik egyes funkciók használatát, másrészt olyan komplex feladatokat is megvalósítanak, mint például az OpenGL inicializálása vagy egy fényforrás beállítása. A harmadik csoportba azok a modulok foglalnak helyet, melyek már csak az előző kettő csoport funkcióin keresztül kommunikálnak és hívnak meg szolgáltatásokat a többi API-ból. Az ilyen modulból van a legtöbb az API-ban. Ezek valósítják meg többek között a modellek feldolgozás, tárolását és az ezekhez tartozó szolgáltatásokat, mint például az eseménykezelést és az objektumhierarchia felépítését. Ebben a fejezetben egyesével megvizsgálunk minden modult. Az áttekintést mindig a modult felépítő osztályoktól kezdjük és innen haladunk felfelé a modulok szintjéig. A fejezet végén pedig elérjük az API legfelső szintjét, ahol minden modul egy rendszerként működik. A motor használatáról a 3. fejezetben olvashatunk. A modulcsoportok sorrendjét is követve, először a felhasznált adatszerkezeteket vesszük számba. Ezt követően a grafikusmagot tekintjük át, mely az OpenGL könyvtárra épül és a második modulcsoport legjelentősebb tagja. A következő a fájlműveletekkel foglalkozó modul, ahol betekinthetünk a modellek és egyéb adatok beolvasásának metodiká- 11

17 jába. Majd az ablakkezelőt kiterjesztő osztályokat ismerjük meg. A harmadik csoportot az eseménykezelő alrendszerrel megismerésével kezdjük el. Szorosan ide kapcsolódik a felhasználó által, a különböző beviteli eszközök segítségével kiváltott interakciók. Az események után áttérünk a egyik legfontosabb részegységre: a grafikus objektumok hierarchiájára, amely felhasználja az összes eddig megvizsgált modult. Az utolsó részben a fények kezelésével és a szöveges információk megjelenítésével fogunk foglalkozni. Végül egy kis ráadásképpen megnézzük a beépített részecskerendszert. 1. Adatszerkezetek és adattípusok A grafikus rendszerek egyik sarkalatos pontja a megfelelően megtervezett és implementált adatstruktúrák. A 3D-s megjelenítéshez nagy mennyiségű adatra van szükség, melyeket a tárolás mellett gyorsan és hatékonyan kell elérni és feldolgozni. Ebben az alfejezetben csak a legfontosabb adatszerkezetekre fogok kitérni. Az ennél összetettebb típusok az ezt követő fejezetekben fogjuk tárgyalni. Mindenek előtt a beépített típusokat veszszük röviden sorra, majd pedig az Ilo-hoz készített osztályokat tekintjük át A Python beépített típusai A Python egy erősen típusos nyelv, melyről könnyen megfeledkezhetünk a dinamikus változókezelésnek és a lusta kifejezés kiértékelésnek köszönhetően. A lusta kiértékelés azt jelenti, hogy például egy függvénynek a paramétereiben átadott kifejezéseket (a mohóval ellentétben) csak akkor értékeli ki a Python, ha azokra valóban szükség van. A dinamikus változókezelésnek köszönhetően nincs szükség a változók deklarálására vagy a típusuk meghatározására. Az interpreter folyamatosan számon tartja az egyes változók aktuális értékeit és típusait. Így a nem megfelelő hivatkozásokat kivétel dobással jutalmazza a nyelv. A Python számos beépített típussal rendelkezik. Ezeket csak egyszerű felsorolás formájában tekintjük át az alábbi listában. Alapadattípusok: Egész számok int, long 12

18 Logikai értékek bool Lebegőpontos számok float Karakterláncok string Gyűjtemények: Listák list, tuple, array,... Szótárak dict Halmazok set, frozenset 1.2. OpenGL típusok A PyOpenGL-nek köszönhetően az OpenGL teljes mértékben illeszkedik a Python környezethez. Például nem szükséges a függvények hívásakor az OpenGL-ben megszokott paraméter konvenciókat használni (pl.: glvertex3f helyett glvertex), a PyOpenGL automatikusan feloldja ezeket a megadott paramétereknek megfelelően. A PyOpenGL ahogy már az előző fejezetben is említettem a numpy-t használja belső adattárolásra (pl.: mátrixok) és bizonyos számítások elvégzésére. Ezen felül csak a Python által biztosított típusokat használja adattárolásra numpy típusok A numpy alapvetően egydimenziós (array), kétdimenziós (matrix) és n-dimenziós (ndarray) adatstruktúrák kezelésére alkalmas (a MatLab-hoz hasonlóan). Nagy előnye, hogy az összes fontosabb vektor és mátrix műveletet képes elvégezni (pl.: vektorok szorzását mátrixokkal). Ezen felül számos egyéb matematika számítást is megvalósítottak benne (pl.: Fourier transzformáció), azonban a motor csak a vektor és mátrix műveletek elvégzéséhez nyújtott funkciókat használja. A következő bekezdésben azt is megtudhatjuk, hogy milyen formában alkalmazza az API a numpy képességeit Vektorok (Vector modul) Az általános vektor osztály a numpy ndarray osztályából származik. Azért nem az egydimenziós tömböt (array) terjeszti ki, mert az nem támogat olyan műveleteket, me- 13

19 lyek igen fontosak a motor szempontjából. Ilyen művelet például egy mátrix szorzása egy oszlopvektorral. A kiterjesztés során a következő metódusokat adtam hozzá: length A vektor hossza azaz elemeinek négyzetösszegének a gyöke. sqrlength A vektor elemeinek négyzetösszege. normal A vektor normalizálása, azaz minden elemét elosztjuk a hosszal. zeros A vektor kinullázása Ebből az általános osztályból származik három másik vektor típus, melyek dimenziók szerint lettek specializálva. Így jött létre a 2, 3 és 4 dimenziós (elemű) vektor típus. Mindegyik osztály felüldefiniálja az általános vektor által biztosított metódusokat a saját dimenziójának megfelelően. Továbbá az adott számú dimenzió miatt, minden elem nevesítve is elérhető, lekérdező és beállító (getter és setter) metódusokon keresztül, melyeknek egyetlen feladata a vektorban szereplő adott sorszámú érték lekérdezése vagy beállítása. A Pythonban lehetőség van speciális úgynevezett property metódusok definiálására. Például: class Osztaly: def init(): a = 10 b = def b(): return def b(value): b = value # public # private # a b-t lekérdező getter metódus # a b-t beállító setter metódus peldany = Osztaly print peldany.a # 10 pritn peldany.b # 20 pritn peldany.b = 30 # paldany. b értéke 30 lesz Működését tekintve teljesen olyan, mint egy metódus hívás, mely lekérdezi vagy beállítja az osztály valamely értékét. Használat közben viszont olyan, mint ha az osztály egy publikus osztályváltozójával végeznénk műveleteket. A vektor osztályok a következő property-ket támogatják: Vector2 Vector3 Vector4 x, y x, y, z x, y, z, w 14

20 1.5. Kvaterniók (Quanternion modul) A matematikában a kvaterniók [18] egy szám négyes, mely a komplex számok egyfajta kibővítése. Az egyik legfontosabb felhasználási területe a 3D-s forgatómátrixok számítása. Legnagyobb előnye, hogy jelentősen kevesebb művelet elvégzése szükséges egy kívánt forgatási mátrix kiszámításához, mintha azt mátrixszorzásokkal adtuk volna meg. Alapvetően elég, ha az x, y, z tengelyek elforgatáshoz tartozó Quanternion-t számoljuk ki, majd ezeket definíció szerint összeszorozzuk. A forgatási mátrix ebből már egy lépésben előállítható. Ábrázolás szempontjából egy négydimenziós vektorról van szó melyet, a Python beépített array osztályának felhasználásával hoztam létre. Az osztály megtervezésében nagy sokat segített a Drome motorban [5] található hasonló osztály Mátrixok (Matrix modul) A vektorokhoz hasonlóan itt is a numpy ndarray objektumából indultam ki és hoztam létre egy általános Matrix osztályt. Ez az osztály nem tartalmaz semmilyen új metódust, lényegében csak egy hivatkozás (alias) az ősére. További három specializált Mátrix származik az ndarray osztályból, rendre 2 2-es 3 3-as és 4 4-es méretűek. Ezek mindegyik három osztálymetódussal rendelkezik: zeros identity rotation Csupa nullákat tartalmazó mátrix. Egységmátrix, azaz csupa nulla mátrix főátlójában egyesekkel. A paraméterben megadott elforgatási szög alapján számítható forgatási mátrix. A 3 3-as és 4 4-es mátrixok esetében tengelyenként eltérő metódussal történik a számítás. A numpy-nek köszönhetően ezek az osztályok már öröklik az összes fontosabb mátrix műveletet, többek között: az összeadást, skalárral való szorzást, mátrixszal való szorzást, mátrix transzponálást és felbontást oszlopvektorokra Modellekkel kapcsolatos struktúrák (d3d modul) Több egyszerű osztály tartozik ebbe a modulba, melyek csak a modellek adatainak 15

21 tárolására szolgálnak. Főként tulajdonság metódusaik vannak, melyekkel beállíthatók az egyes adattagok. Éppen ezért csak röviden elemezzük őket. Vertex: A csúcspont (vertex) a 3D-s modellek legkisebb építőeleme, mely lényegében egy pont a térben. A legfontosabb tulajdonsága a térbeli pozíciója, melyet három számmal (x, y, z) írhatunk le. Ennek a pontnak a homogén koordináta rendszerbeli helyét a következő szám négyes adja: (x, y, z, w). Az API minden pont homogén koordinátájának negyedik értékét konstans 1-nek veszi, ezért azt elhagyhatjuk. Ha a csúcspont egy felület részét képezi, akkor szükség lehet a csúcs normálvektorára is. A normálvektor egy egység hosszú vektor, amely mindig merőleges a csúcsot tartalmazó felületre és egy (x, y, z) hármassal írhatjuk le. A Vertex osztály tárolja a normálvektor koordinátáit is. VertexUV: Ez az objektum a csúcspontokhoz tartozó textúrakoordinátákat tárolja, mégpedig két darab szám formájában (u, v). Ez a két szám egy pontot határoz meg a 2D-s képen, melynek felbontásától függetlenül minden pontjának koordinátája 0-tól 1-ig tart. Ebben a rendszerben a kép bal felső sarka az origó, azaz a (0, 0) pont. A nem a [0-1] tartományba eső számok esetében a rendszer az éppen aktuális textúraleképezési paraméterek szerint jeleníti meg a képet a felületen. Ezekkel a paraméterekkel meghatározhatjuk azt is, hogy a rendszer hogyan viselkedjen ha az (u, v) értékek nem a [0-1] intervallumba esnek. Azért nem a Vertex osztályban van eltárolva az (u, v) számpár, mert általában poligononként vannak beállítva a textúrák és így egy csúcsponthoz, több textúrakoordináta is tartozhat. Edge: Két csúcspontot összekötő szakaszt nevezünk élnek (edge). Az él objektum két csúcsponthivatkozást tartalmaz. Mivel minden élhez minimum egy, de legfeljebb két poligon (face) kapcsolódik, ezért az osztály képes tárolni két Face objektumhivatkozást is a könnyebb feldolgozás érdekében. Face: A poligon (face) egy élek által határolt terület. Egy poligonnak tetszőleges számú 16

22 oldala lehet. Az API azonban csak a három csúcsponttal vagy ugyanennyi éllel megadható háromszög poligonokkal tud dolgozni. Ez a felületleképezés alapegysége is. Így a Face osztály a három csúcspontot, a hozzájuk tartozó textúrakoordinátákat, és a poligon normálvektorát tároljuk. A poligon normálvektora a csúcspontok koordinátáiból számítható, n = (B A) (C A) ahol ṉ a normálvektor, és az A, B, C a lap csúcsai. BoundingBox: Ez az osztály a modell legkisebb és legnagyobb koordinátájú pontját számítja ki és tárolja le. Az így kapott két csúcs, a modell köré rajzolható legkisebb téglalapot határozza meg. Többek között az ütközés vizsgálatkor lehet hasznos. BoundingShpere: Az előzőhöz hasonló objektum, mely a modell köré írható gömböt adja meg, oly módon, hogy átlagoljuk a csúcspontok koordinátáit így megkapva a gömb középpontját, majd megkeressük a középpontól legtávolabbi csúcsot és ez a távolság adja meg a sugarat. Szintén ütközés vizsgálat során lehet hasznos. 2. Grafikus mag A Gfx nevű modul kapcsolja össze a PyOpenGL-t a motor többi részével, ezáltal minden leképezéssel és grafikus megjelenítéssel kapcsolatos eljárás egy helyen van. Szintén az egységes kezelés érdekében a modul csak és kizárólag egyke (singleton), azaz egyszer példányosítható osztályokat tartalmaz (bővebben a következő alfejezetben). Ebből egyenesen következik, hogy egyszerre csak egy leképező környezetet tud kezelni az API. Öt osztály található a modulban. Az első a Gfx amely csak a leképezéshez kapcsolódó és az objektumok létrehozásához szükséges konstansokat tartalmazza. A következő a GfxContext melynek közvetlen leszármazottja a GLContext-t. Ez a két osztály tartalmazza az API-ban használt OpengGL függvények "alias"-ait. Az alias-ok olyan methódusok, amelyek nem értelmezik újra az eredeti függvényt, csak egy másik néven hivatkoznak azokra. Mindezt azért, hogy mindenhol elég legyen csak a Gfx osztályt 17

23 importálni. Továbbá itt találhatók a különböző leképezési meneteket (render pass) előkészítő és lezáró metódusok. A negyedik osztály a GLContext egyik belső osztálya (inner vagy nested class), a GfxMatrix. Az egyetlen feladata az OpenGL-es mátrixutasítások magasabb szintű kezelése. Végül az ötödik osztály a Viewport, ami az aktuális látómező paramétereit tárolja, és ezen keresztül állíthatjuk be azokat. Az alábbiakban részletesebben is megvizsgáljuk a modul egyes elemeit. Mindezek előtt teszünk egy rövid kitérőt az egykeosztályok felé Singleton osztályok A singleton osztály (más néven egykeosztály) [19] egy programtervezési minta (pa t - tern), ami olyan osztályok létrehozására ad egy elvi felépítést melyek csak egyszer példányosíthatók a program futása során. Ennek megvalósítása nagymértékben nyelvfüggő és többféleképpen is implementálható egy adott nyelven. Az Ilo-ban használt implementáció: class Singleton: instance = None def Singleton (): if instance!= None: instance = new Singleton else: raise SingletonClassError # A létező példány tárolója # new metódust definiálása def getinstance (): # A létező példány lekérdezése return instance A Python két lépésben hozza létre az osztályokat: az első fázisban maga az objektum jön létre, ezt a new metódus (magic function olyan metódus amely az interpreter számára speciális jelentéssel bír) definiálásával érhetjük el. A második fázisban a létrehozott objektum értékeinek inicializálása történik az init metódus segítségével. Mint a legtöbb objektumorientált nyelvben, itt is minden osztály ősosztálya az object (Pythonban a beépített osztályok kisbetűvel kezdődnek). Ebből kifolyólag a new, és az init metódus megadása elhagyható, ekkor az object osztály ugyan ezen metódusai hajtódnak végre. A Singleton osztálynak van egy protected, (csak a leszármaztatott osztályok számára látható) instance nevű adattagja. Ez tárolja az osztály egyetlen létező példányát. A konstruktort előbb ellenőrzi az instance osztályváltozó értékét és ha az None, akkor lét- 18

24 rehozza az osztály egy példányt és hozzárendel az instance változóhoz, különben SingletonClassError típusú kivétel keletkezik. Ezek után a getinstance osztálymetódussal kérhetjük le a létező osztálypéldányt. Azért nem a getinstance inicializálja az instance változót mert így elkülöníthető az első létrehozás fázisa a tényleges használa t - tól. Ezzel a módszerrel elkerülhetők azok a helyzetek, amikor még az OpenGL környezet létrehozása előtt hívunk meg olyan metódusokat amelyek csak az inicializálást követően lennének elérhetőek. Így lehetőség van arra, hogy az osztály konstruktorát az inicializálás megfelelő fázisban hívjuk meg, ezáltal az API használatakor már csak a getinstance metódussal érhetjük el az adott osztály referenciáját, amely már biztosan létezik Gfx osztály Ez egy statikus osztály, ami azt jelenti, hogy kizárólag olyan metódusokat és adattagokat tartalmaz amelyeket csak példányosítás nélkül érhetők el. Az Ilo motorban minden statikus osztály példányosításakor StaticClassError kivétel keletkezik. A Gfx annyiban tér el más statikus osztályoktól, hogy csak és kizárólag konstans adattagjai vannak és nem tartalmaz műveleteket. Ezek a konstansok nagyrészt OpenGLban definiált értékekre hivatkoznak. Ilyen konstans például a GL_PROJECTION melyre a projekciós mátrix elérésekor van szükség. Ezek a hivatkozások általában az eredetitől csak minimálisan térnek el. Rövidebb azonosítókkal rendelkeznek. Továbbá a Gfx az API számára az OpenGL-től független, viszont a leképezés szempontjából fontos értékeket is tárol, mint éldául: a NUM_TEXTURE_UNITS mely a textúrázási rétegek számát határozza meg. A Gfx osztály (mivel globálisan elérhető) ezért csak olyan állandókat tartalmaz, melyekre szükség lehet a program más részeiben is. Ezzel a módszerrel elrejthetünk bizonyos konstansokat a motor egyes részei elől. Természetesen az PyOpenGL modul importálásával az összes konstans elérhetővé válik. Pontosan emiatt a Gfx osztály nem tartalmazza az összes OpenGL konstans alias-át. Később látni fogjuk, hogy például a GLWidget osztálynak pontosan erre a csökkentett konstanskészletre van szüksége. 19

25 2.3. GfxContext és GLContext osztályok Mivel a GLContext a GfxContext közvetlen leszármazottja ezért ezt a két osztályt együtt vesszük szemügyre. A GfxContext minden a motorban implementált leképezőkörnyezet (az Ilo-ban csak az OpenGL van megvalósítva) alaposztálya mely csak a környezettől független általánosan használható metódusokat definiál. Míg a GLContext osztályban az OpenGL környezettől függő utasításokat foglalnak helyet. A GLContext egyszerre több feladatot is ellát. Először is a példányosítás során előbb ellenőrzi az összes felhasznált OpenGL utasítás elérhetőségét, miközben létrehozza az adott függvényekre a saját hivatkozásokat (alias képzés). Ezek után elvégzi a leképezéshez szükséges alapbeállítások inicializálását, beállít minden fontosabb OpenGL értéket ami a program futása során nem (vagy csak speciális esetekbe) változik (pl.: glshademodel, glhint, glpolygonmode, stb.). Szintén ebben a szakaszban inicializálódik a viewport és a gfxmatrix kezelő alrendszer (lásd a következő bekezdésekben), továbbá itt töltődik be és generálódik le a szövegkiíratáshoz szükséges struktúra. A szövegkiíratáshoz szükséges betűk létrehozásához a gllist nevű OpenGL-es objektumot veszszük segítségül. Ez az objektum csak adott OpenGL utasításokat képes tárolni (többek között: glbegin, glend és minden ami azok között is lehet). A lista létrehozását követően, egyetlen parancs kiadásával tetszőleges mennyiségben végrehajthatjuk, ezzel memóriát, CPU és GPU időt spórolva. Példaként vegyük egy betűhöz kirajzolásához szükséges 2D-s sík lap létrehozását: glnewlist(font + i, GL_COMPILE) glbegin(gl_quads) gltexcoord2f(0, 0) glvertex2i(0, 0) gltexcoord2f(1, 0) glvertex2i(16, 0) gltexcoord2f(1, 1) glvertex2i(16, 16) gltexcoord2f(0, 1) glvertex2i(0, 16) glend() gltranslate(12,0,0) glendlist() # Új gllist létrehozása # Az első tárolt utasítás # Az utolsó tárolt utasítás # A gllist lezárása A betűk generálásakor minden egyes karakterhez létrehozunk egy ilyen listát. A szövegkiíratás működéséről és kezeléséről a 8. fejezetben olvashatunk bővebben. 20

26 2.4. GfxMatrix osztály Ennek az osztálynak egyetlen feladata az OpenGL-ben használható mátrixok (GL_PROJECTION_MATRIX, GL_MODELVIEW_MATRIX, GL_TEXTURE_MATRIX) közötti átváltás és, azok lekérdezéseinek és beállításainak leegyszerűsítése. Először is minden mátrixműveletnél megadható, hogy melyik mátrixon szeretnénk azt elvégezni. Ha nem adjuk meg ezt a paramétert akkor az OpenGL számára aktuálisan beállított mátrixon hajtódnak végre a műveletek. A következő mátrixműveleteket végezhetjük el az osztály segítségével: getmatrix A megadott mátrix aktuális értéke Matrix4x4-ben setmatrix A megadott mátrix beállítása multiplymatrix A megadott mátrix beszorzása egy másikkal loadidentity A megadott mátrix beállítása az egységmátrixra Az OpenGL oszlop-sor formában tárolja a mátrixokat ezért az egyes műveletek (pl.: mátrix lekérdezése) esetében szükség lehet a mátrix transzponálására (a mátrix sorainak és oszlopainak felcserélése). Ehhez használhatjuk a Matrix4x4 transpose metódusát. A mátrixok típusok közötti váltásokat az API folyamatosan elmenti és tárolja, így könnyen visszakövethetjük, hogy melyiket használtuk utoljára. Az utolsó állapotot egyetlen metódushívással visszaállíthatjuk (previewmatrix), továbbá az éppen használatban lévő mátrix típusa is lekérdezhető (currentmatrix). Fontos megjegyezni, hogy a GfxMatrix nem egy önálló osztály: valójában a GLContext egy belső osztálya (Java-ban nested vagy inner class). A Pythonban bárhol deklarálhatunk új osztály, akár egy másik osztályon belül is (sőt függvények törzsében is!). Az így létrehozott osztályra csak az őt tartalmazón keresztül hivatkozhatunk. Erre a megoldásra azért volt szükség, mert ezeknek a mátrixoknak a kezelése teljes mértékben a GLContext feladatkörébe tartozik, viszont ezen belül mégis egy külön egységet képez melyet a GfxMatrix valósít meg. Ezen felül a GfxMatrix is singleton, mivel ez az osztály is rendszer szintű műveletek lát el. Szükség esetén a GfxMatrix funkciói elérhetők a GLContext, matrix adattagján keresztül. 21

27 2.5. Viewport osztály Mielőtt elmélyednénk az osztály részletezésében, előbb vizsgáljuk meg az OpenGL vetítéssel kapcsolatos tulajdonságait. A 3D-s leképezés során a perspektivikus és az ortogonális vetítés közül választhatunk az OpenGL-ben. Az alábbi ábra mindkettőt szemlélteti: II. 1. ábra: Perspektivikus és párhuzamos vetítés vágósíkjainak szemléltetése Az 1. ábán balra a perspektivikus vetítést láthatjuk, melynek legszembetűnőbb sajátossága, hogy a párhuzamos egyenesek a nézőponttól távolodva, mintha fokozatosan özsszetartanának (pl.: vasútisinek). Ebből az is következik, hogy a megfigyelt objektumok élei látszólag nem olyan szöget zárnak be mint ami várható lenne (pl.: egy kocka derékszögei). Ezzel szemben a kép baloldalán látható párhuzamos (más néven ortogonális) vetítés, szögtartó (azaz nem torzítja a szögeket). Amiért mégis előnyben részesítjük a perspektivikus vetítést a 3D-s grafikában, az az, hogy az emberi látáshoz ez áll a legközelebb, és ez szükséges a megfelelő térérzékeléshez is. Az ábrán jól látható, hogy 6 sík lap határolja a látómezőt. Ezeket a lapokat vágósíkoknak is nevezzük, mivel az OpenGL az ezen kívül eső elemeket egyszerűen levágja. Így csak a síkokon belüli pontok vesznek részt a leképezés folyamatában, tehát a jól megadott vágósíkokkal megtakaríthatunk némi számítási kapacitást és jelentős mennyiségű memóriát. Érdemes még megfigyelni az ábrán a koordinátarendszer állását, ugyanis jól látható az OpenGL által használt jobbsodrású rendszer, továbbá azt is észrevehetjük, hogy a z tengely határozza meg a 3D-s tér mélységét, azaz a z tengely merőleges a monitor síkjára. 22

28 Az előzőekhez hasonlóan a Viewport is egy singelton osztály. Feladata a látómező beállításainak elvégzése. Tárolja az aktuális OpenGL látómező x és y pozícióját, továbbá a szélességét és a magasságát (az ábrán az a és b élek). Ezek az értékek a program ablakának lokális koordináta-rendszerében értendők, továbbá a látómező méretei nem szükségszerűen egyeznek meg a főablakéval. Az osztály tartalmazza a látómező képarányát (ration) is. A képarány (az ábrán szereplő a és b élek aránya) megadása szükséges a perspektivikus vetítés kiszámításához. A nem megfelelő arány esetén a kiszámított kép torzulhat és az objektumok vízszintesen vagy függőlegesen nyújtottak lehetnek. A látószög (FOV Field Of View) paraméter, (az ábrán lévő oldalsó vetítősíkok, C és D által bezárt szög az O origóból nézve) szintén fontos adat a vetítés megadásakor. Értéke fokban értendő. Ez határozza meg, hogy a kamera mekkora térrészt képes egyszerre belátni. Az emberi szemnek megfelelő optika látószöge kb. 50. A FOV értékét az API konfigurációs fájljában lehet megadni. Valamint az osztály tárolja a legközelebbi (nearplane) és a legtávolabbi (farplane) vágósíkokat is (az ábrán az A-val és B-vel jelölt síkok). Az osztály metódusai segítségével beállíthatjuk a látómező méretét, amit a motor automatikusan is meghív minden ablakátméretezés alkalmával. A metódus hívásakor nem csak a látómező méreteződik át, de a képarány, a közeli és a távoli vágósíkok is itt kapnak értéket. A vágósíkok nézőponttól való távolságát jelenleg az Ilo határozza meg, két konstans érték formájában. Ezek az információk szükségesek az új látómezőhöz tartozó perspektivikus vetítési mátrix kiszámításához. Ehhez a gluperspective függvényt hívjuk segítségül, mely kiszámítja az új vetítési mátrixot és be is állítja azt az OpenGL-ben. 3. Fájlkezelés Három különböző fájl formátum feldolgozására van szükség az Ilo-ban: Szöveges fájl: ASE modell fájl XML fájl: konfigurációs fájlok, anyagjellemző gyűjtemények, színtér leírók Bináris fájl: képek A szöveges fájlok feldolgozása a legegyszerűbb a megfelelő specifikáció birtokában. 23

29 A Python a fájl kezelést is megkönnyíti. Elég az open függvény segítségével megnyitni a dokumentumot. Az így kapott file objektum iterálható, ami azt jelenti, hogy egy for ciklus segítségével beolvashatjuk a fájl tartalmát, a ciklus változó minden iterációban a fájl következő sorát kapja értékül. A ciklus magjában string műveletekkel a fájl leírásának megfelelően feldolgozhatjuk az egyes sorokban tárolt információt. inputfile = open("path/file", "r") for line in inputfile: parseline(line) # Fájl megnyitása olvasásra ("r") # Fájl beolvasása soronként # A sorok értelmezése Az XML (extensible Markup Language) fájlok értelmezésére (parse) a Python-ban található minidom nevű modult használtam. A minidom csak a legalapvetőbb értelmezési funkciókat biztosítja, viszont az Ilo-ban felhasznált struktúrákhoz ezek is bőven elegendők. A modul az XML fájl betöltésekor azonnal értelmezi annak tartalmát és felépít belőle egy belső adatstruktúrát (DOM Document Object Model). A DOM lényegében egy objektumhierarchia melyben az egyes elemek tartalmazhatnak újabb elemeket, illetve mindegyiknek meg van a saját metódus- és adattagkészlete, mely segít a struktúra bejárásában, az adatok kiolvasásában és a tulajdonságok megváltoztatásában. A képek a bináris fájlok kategóriájába tartoznak. Feldolgozásukra a Python által biztosított Image osztályt használjuk, amely a PIL [20] (Python Image Library) része. A PIL képes beolvasni és kezelni az összes elterjedtebb képformátumot és a motor számára megfelelő formátumba konvertálni (erről bővebben az 5. Anyagjellemzők fejezetben olvashatunk). Az általános bináris fájlok értelmezéséhez már saját osztályt kell készíteni. Ehhez hasznos lehet a Struct nevű osztályt, ami egy szöveg változóban megadott formátummaszk alapján értelmezi az adatokat és ennek segítségével blokkosítva dolgozhatjuk fel az adott fájlt. Így az egyes blokkok kinyerését követően a feldolgozás menete megegyezik a sima szöveges dokumentuméval. A formátummaszkok (az egymást követő bájt blokkok jelentését leíró string) leírását a fájl formátumának a specifikációja határozza meg. A fájlok kezelésére nincs központosított rész az API-ban. Az anyagjellemző kollekciókat és a színtér fájlokat a Library osztály kezeli, míg a konfigurációs állományt a Config osztály dolgozza fel. A következő alfejezetekben ezekről lesz szó. 24

30 3.1. Konfigurációs fájl Az API legfontosabb beállításait alapértelmezetten a config.xml fájl tartalmazza. A fájl kategóriákra bontva tárolja az egyes beállításokat. Egy bejegyzésnek három attribútuma van: név, érték és típus. Az alábbi példa a library_init értéket logikainak definiálja és True-ra állítja: <iloconfig> <category name="base"> <item name="library_init" value="true" type="bool" /> </category> </iloconfig> A konfigurációs fájl betöltését és feldolgozását a config modul Config osztálya végzi. Az értékek négyféle típusúak lehetnek: logikai (bool), egész szám (int), lebegőpontos szám (float) és karakterlánc (string). A betöltés folyamán az értékek a típusuknak megfelelő konverzión esnek át. A Config osztály csak osztálymetódusokat tartalmaz. A Config osztály a következő metódusokat biztosítja az adatok kezelésére: loadconfigxml Konfigurációs fájl betöltése reset Konfigurációs értékek törlése, alapértékeket kivéve hasvalue Szerepel-e a megadott beállítás az adatbázisban getvalue A megadott beállítás lekérdezése A Config osztály már a konfigurációs fájl betöltése előtt is tartalmaz számos beállítást, melyek elengedhetetlenül fontosak a motor megfelelő működéséhez. A konfigurációban szereplő értékeket egy dict nevű beépített struktúrában (dict azaz dictionary, leginkább egy asszociatív tömbre hasonlít) tároljuk, mégpedig a következő formában: dict["categoryname.itemname"] = value A konfigurációs állományba tetszőleges mennyiségű és típusú értéket felvehetünk, ezáltal nem csak az API beállításait, de a ráépülő program paramétereit is tartalmazhatja. Sőt akár több konfigurációs fájlt is betölthetünk egyszerre. Azt azonban figyelembe kell venni, hogy a megegyező paraméter nevek (kategória és név együtt) esetén a később betöltött értékek felülírja a korábban beolvasottakat. 25