Tento program pokračuje přidáváním chování (rotace, interakce myší pokrytá v kapitole 4) a světel (kapitola 6) aby bylo možno model osvětlit. Samozřejmě můžete s 3D modelem v Java3D provádět mnoho dalších věcí jako je animace, vkládání ostatních geometrických objektů, měnit barvu modelu atd.

3.3.2 Veřejně dostupné loadery

Existuje mnoho loaderů pro prostředí Java3D. Následující tabulka obsahuje seznam veřejně dostupných loaderů. V době psaní tohoto tutoriálu byl k dispozici alespoň jeden loader pro každý typ souboru uvedený v tabulce.

Pro aktuální seznam dostupných loaderů ddopručujeme prohledat internet.

3.3.3 Balíček loaderů s rozhraními a základními třídami

Počet a množství druhů loaderů existují protože návrháři Java3D umožnili je jednoduše napsat. Třídy loaderů jsou imlementacemi orzhraní Loader které usnadňuje tvorbu loaderů. Mnohem důležitějším faktem ale je, že rozhraní nutí různé loadery mít konzistentní rozhraní.

Stejně jako v ukázce výše, program načítající soubor obsahující 3D data používá jak objekt loaderu tak objekt scény. Loader čte, parsuje a vytváří Java3D reprezentaci obsahu souboru. Objekt scény pak uchovává graf scény vytvořený loaderem. Je možné načítat scény z více než jednoho souboru (stejného formátu) za použití jednoho objektu loaderu vytvářejícího více objektů scény. Soubory různých formátů mohou být kombinovány v Jav3D programu za použití příslušných loaderů.

Následující referenční blok obsahuje seznam rozhraní v balíčku com.sun.j3d.loaders. Loader implementuje rozhraní Loader a používá třídu implementující rozhraní Scene

Rozhraní balíčku com.sun.j3d.laoders

Loader Rozhraní se používá k určení polohy a prvků formátu souboru který se má načíst.

Scene  Rozhraní je sadou metod používaných k extrakci informace o Java3D grafu scény z loaderu.

Mimo tyto rozhraní obsahuje balíček com.sun.j3d.loaders základní implementace těchto rozhraní.

Třídy balíčku com.sun.j3d.loaders

LoaderBase tato třída implementuje rozhraní Loader a poskytuje konstruktory. Tuto třídu můžete rozšířit k vytvoření specifických loaderů.

SceneBase  tato třída implementuje rozhraní Scene a rozšiřuje ho k začlenění metod používaných loadery. Tato třída je využívána programy které používají loadery.

Metody definované tímto rozhraním jsou používány programátory používajícími loadery.

Metody rozhraní Loader

Balíček: com.sun.j3d.loaders

Rozhraní Loader se pooužívá k určení polohy a prvků formátu souboru který se má načíst. Rozhraní je umožňuje loaderům různých formátů souborů mít společné veřejné rozhraní. Ideálně rozhraní Scene umožňuje uživateli mít jednotné rozhraní k extrakci dat.

Scene load(java.io.Reader reader)

Tato metoda načítá Reader vrací objekt Scene obsahující scénu.

Scene load(java.lang.String filename)

Tato metoda načítá jmenovaný soubor a vrací objekt Scene obsahující scénu.

Scene load(java.net.URL url)

Tato metoda načítá soubor z url a vrací objekt Scene obsahující scénu.

void setBasePath(java.lang.String pathname)

Tato metoda nastavuje cestu k datovým souborům asociovaným se souborem předaným metodě load(String)

void setBaseUrl(java.net.URL url)

Tato metoda nastavuje url k datovým souborům asociovaným se souborem předaným metodě load(URL)

void setFlags(int flags)

Tato metoda nastavuje příznaky souboru:

Třída Loaderbase obsahuje implementaci každé ze tří verzí metody load() rozhraní Loader. Třída LoaderBase také implementuje dva konstruktory. všimněte si že všechny tři metody vrací objekt Scene.

Konstruktory třídy LoaderBase

Balíček: com.sun.j3d.loaders

Implementuje: Loader

Tato třída implementuje rozhraní Loader. Autor nového loaderu by měl tuto třídu rozšířit. Uživatel loaderu by měl používat tyto metody.

LoaderBase()

Vytváří Loader s defaultními hodnotami všech proměnných

LoaderBase(int flags)

Vytváří Loader s danými příznaky

Mimo těchto konstruktorů používají programátoři metody v následujícím referenčním bloku. Při psaní loaderu může autor nového loaderu rozšířit třídu LoaderBase definovanou v balíčku com.sun.j3d.loaders. Nový loader poté používá třídu SceneBase ze stejného balíčku.

Budoucí loadery mohou rozšířit buï třídu SceneBase nebo implementovat rozhraní Scene přímo, i když použití třídy SceneBase je opravdu přímočaré. Třída SceneBase je zodpovědná za ukádání a získávání dat vytvořených loaderem při čtení souboru. Metody k získávání dat (používáné primárně uživateli Loader) jsou všechny metody get*.

Při rozšiřování třídy loaderu bude většina práce spočívat v napsání metod rozpoznávajících rozdílné typy obsahu které představují formát souboru. Každá z těchto metod pak vytvoří odpovídající komponentu grafu scény Java3D a uloží ji v objektu Scene. V následujícím referenčním bloku najdete seznam konstruktorů třídy SceneBase.

Konstruktor třídy SceneBase

Balíček: com.sun.j3d.loaders

Rozšiřuje: Scene

Tato třída implementuje rozhraní Scene a rozšiřuje jej k začlenění utilit které mohou používat loadery. Tato třída je zodpovědná za ukládání a získávání dat z objektu Scene.

SceneBase()

Vytváří objekt SceneBase - neměl by být žádný důvod k používání tohoto konstruktoru kromě implementace nové třídy loaderu.

Metody třídy SceneBase

Tento referenční blok jen jednoduše uvádí seznam metod.

Background[] getBackgroundNodes()

Behavior[] getBehaviorNodes()

java.lang.String getDescription()

Fog[] getFogNodes()

float[] getHorizontalFOVs()

Light[] getLightNodes()

java.util.Hashtable getNamedObjects()

BranchGroup getSceneGroup()

Sound[] getSoundNodes()

TransformGroup[] getViewGroups()

Jak jsme si řekli výše, jednou z nejdůležitějších možností loaderů je napsat si svůj vlastní - což znamená že všichni další uživatelé Jav3D mohou také!

3.4 Píšeme loader

Psaní loaderu je velmi komplexní úloha kterou ne všichni vývojáří Java3D aplikací podstoupí. I když už teï víte že nebudete chtít naspat si svůj vlastní loader, může vám tato sekce poskytnout různé informace:

• kdy použít loader
• porozumět používání objektu GeometryInfo
• porozumět implementaci třídy ObjectLoader

Avšak pokud vás tyto body nezaujaly a nechcete si zkusit napasat vlastní loader nyní, klidně se přesuňte na další sekci.

Pro ty kteří mají zájem vytvořit vlastní loader pokračuje tato sekce přehledem některých komlexníxch úloh při psaní loaderu, následovaným konstrukcí jednoduchého loaderu a v závěru vás čeká malá analýza struktury OBJLoader.

3.4.1 Co loadery dělají

Předtím než podstoupíme složitou operaci psaní loaderu, můžeme trochu popřemýšlet o věcech které loader může dělat. Obvykle je základní úlohou loaderu číst geometrii ze souboru a vyprodukovat graf scény který reprezentuje obsah souboru. Ale může dělat i spoustu jiných věcí. Například, loader může:

• vypočítat povrchové normály pro polygony
• umístit geometrii na počátek souřadnic
• upravit rozměry na rozmezí -1 až 1 podél každé osy
• vyhladit geometrii
• provést stripifikaci
• vytvořit mnohonásobnou reprezentaci geometrie pro techniku LOD

Některé z těchto vlastností jsou implementovány v dostupných loaderech a některé z nich jsou implementovány třídou GeometryInfo a jiných třídách utilit Java3D.

Samozřejmě loader nemusí implementovat všechny tyto vlastnosti; může jen jednoduše splnit svou základní funkci. To je přesně to co náš první loader bude dělat. Později si povíme jak ho upravit aby uměl dělat i ostatní věci ze seznamu.

3.4.2 Konstrukce základního loaderu

Psaní loaderu je zajímavý proces který zahrnuje detailní znalosti o formátu souboru pro který chceme loader napsat. Psaní loaderu také zahrnuje znalost Java datových proudů, což je mimo hranice tohoto tutoriálu.

Existuje mnoho způsobů jak napsat vlastní loader. To záleží na zamýšleném použití loaderu. Pro maximální pružnost návrhu uvažujme o třídách Scenebase a LoaderBase. Loader postavený na těchto třídách umožní uživateli vybrat které části souboru se použijí v aplikaci. Toto je standardní metoda pro vývoj loaderu. Jiná alternativa zahrnuje vytvoření loaderů pro specifickou apliakci bez tříd SceneBase a LoaderBase.

Jinou proměnnou při vytváření loaderu je typ informace obsažený v souboru který se má načíst. Některé formáty souborů jsou velmi jednoduché; jiné velmi komplexní. Nejjednodušší jsou soubory obsahující jen samotnou geometrii. Komplexnější formáty souborů se mohou odkazovat na jiné soubory anebo mohou obsahovat popis grafu scény. S tím souvisí i fakt že třída loaderu může obsahovat pár set nebo pár tisíc řádek kódu.

Složitost vytváření loaderu je ulehčena díky používání softwarových vrstev. Počet těchto vrstev se může lišit v závislosti na složitosti formátu souboru. Následující tabulka ukazuje možnou sadu vrstev.

Tokenizer

Tokenizer je nejnižší vrstvou. Tato vrstva načítá soubor a tokenizuje jeho obsah. Jeden token je nejmenší jednotkou informace v souboru. Jeho příkladem může být číslo, slovo nebo jeden znak. Tokeny mohou tvořit větší části informací. Například poloha vrcholu může být složena ze tří (x, y, z) číselných tokenů.

Objekt

Objektová vrstva vytváří grafické objekty z tokenů v souboru. "Objekty" mohou být vrcholy, normály, polygony, světla, textury nebo jakýkoli jiný objekt scény v Java3D API. Tyto objekty jsou složkami scény.

Scéna

Kolekce grafických objektů tvoří scénu nebo scény. tato softwarová vrstva je obvykle jednoduchá. Výjimkou je pouze loader formátu souboru který představuje graf scény. Takovými formáty souborů jsou OpenInventor a OOOGL formát.

Soubor

Tato softwarová vrstva řeší problémy s pojmenováváním zdrojů (url nebo jména souborů) a ostatní detaily načtítání scény. tato vrstva se lehce dotýká informací o geometrii obsažených v souboru.

3.4.3 Vytvoření velmi jednoduchého loaderu

Prvním úkolem je vybrat formát souboru pro který budeme loader psát. Obvykle je tento výběr řízen nějakým vnějším vlivem (tzn. máme nějaký konkrétní formát který chceme načíst). Druhým úkolem je nasbírat informace o formátu. Nezbytně nutné jsou definice (specifikace) formátu souboru a soubor pro experimentování.

Pro tento tutoriál jsme vybrali dobře zdokumentovaný formát pro který v době psaní tohoto tutoriálu žádný loader neexistoval. Popravdě, nevybrali jsme jen jeden formát ale rodinu formátů - těch co patří do rodiny OOGL.

Formát OOGL znamená "Object Oriented Graphics Library". tato knihovna se používá pro více úloh než jen pro formáty souborů; používá ji aplikace Geomview, interaktvní prohlížeč 3D objektů. Více informací o programu Geomview můžete najít na www.geomview.org. Tčást knihovny souborů je také známa jako "Geom File Formats" nebo "Geom View File Formats".

Informace o formátu QUAD

Opět, prvním krokem při psaní loaderu je znalost formátu souboru. Tato úloha je mnohem jednodušší pokud je formát souboru zdokumentován a dokumentace je volně přístupná. Pokud nemáte jeho definici, může zkusit nejaít něco na webu. Alternativou je dekódovat formát souboru z různých souborů se známým obsahem. Proes dekódování je ale obvykle cestou pokusů a omylů a zde se jím nebudeme zabývat.

Dostupnost dokumentace formátu QUAD byla jedním z hlavních kritérií proč jsme pro tento tutoriál. tento formát je dobře zdokumentovaný v sekci čtyři dokumentace k programu Geomview která je dostupná online. Sekce čtyři obsahuje obsahuje následující informace o formátech OOGL:

Většina OOGL formátů jsou ASCII soubory - mohou obsahovat jakékoli množství bílých znaků (mezery, tabulátory, nové řádky) mezi tokeny (čísla, klíčová slova atd.). Zarážky jsou nevýznamné, kromě pár výjimek. Komentáře začínají znakem "#" a platí do konce řádku.

Mezi formáty OOGL najdeme i formát QUAD. Tento formát definuje kolekci čtyřúhelníků. Dále je ve specifikaci uvedeno:

Hlavička souboru "QUAD" identifikuje formát souboru. Soubor QUAD je seznam 4 * n vrcholů kde n je počet čtyřúhelníků. Vrcholy jsou určeny jednoduše pomocí souřadnic x, y, a z bodu.

Následující příklad ukazuje obsah jednoduchého QUAD souboru. Přesněji, čtyřúhelník je jednoduchý čtverec v rovině xy na pozici z = 0.

QUAD
-1 -1  0
 1 -1  0
 1  1  0
-1  1  0

Formát QUAD může být mnohem složitější než předchozí ukázka, ale úkolem této sekce je vyvinout jednoduchý loader a proto potřebujeme jednoduchost. Pro více informací o formátu QUAD se podívejte do sekcí 4.2 a 4.1.3 dokumentace programu Geomview.

Teď když dobře rozumíme formátu souboru, můžeme implementovat loader. Následující tabulka obsahuje třídy a vztahy mezi nimi při implementaci jednoduchého loaderu formátu QUAD. Tato tabulka obsahuje jen jednu možnou implementaci.

Tabulka také obsahuje vrstvu o které jsme se ještě nezmiňovali; aplikační vrstvu. Tato vrstva je program který byste měli napsat pro jednoduché načítání. Každé jméno třídy vyznačené tučně koresponduje se jménem souboru v adresáři examples/loader.

V následujících podsekcích budeme jednotlivé třídy implementovat. V tomto projektu budeme vytvářet jednu vrstvu po druhé a začneme tou nejnižší (tokenizerem). Kód tohto projektu není orginální - hodně je ho převzato ze třídy ObjectLoader Java3D API. Avšak je velmi zjednodušen aby se mu dalo lehce porozumět.

Implementace vrstvy tokenizer

Prvním krokem při vytváření loaderu je konstrukce tokenizeru. To zahrnuje úpravy třídy StringTokenizer. Třída StringTokenizer čte proud znaků a převádí ho na proud tokenů. Je lepší si něco přečíst o třídě StringTokenizer před tím než budete psát svůj loader.

Například v našem loaderu je třída StreamTokenizer upravena rozšířením na třídu nazvanou QuadFileParser. Tato třída obsahuje následující metody.

Metoda setup() je místo pro kód k formátu souboru QUAD. Je to místo kde se nastavují specifika formátu souborů pro toeknizer. Podstatné úpravy tokenizeru zahrnují:

• které znaky mají speciální význam
• zda mají znaky nového řádku nějaký význam
• který znak, pokud nějaký, značí komentář

Tyto informace poskytuje formát souborů.

1. class QuadFileParser extends StreamTokenizer {
2.	// metoda setup() nastavuje StreamTokenizer pro čtení OOGL souborů
3.	void setup() {
4.		resetSyntax();
5.		// znaky nového řádku v QUAD formátu ignorujeme
6.		eolIsSignificant(false);
7.		wordChars('A', 'z');
8.		// necháme StreamTokenizer parsovat čísla (s dvojitou přesností)
9.		parseNumbers();
10.		// komentáře začínají znakem # a platí až do konce řádku
11.		commentChar('#');
12.		// bílé znaky obkopují čísla a znaky
13.		// mezery, taby a ynakz nového řádku jsou považovány v OOGL za bílé znaky
14.		whitespaceChars('\t', '\r'); // ht, lf, ff, vt, cr
15.		whitespaceChars(' ', ' '); // mezera
16.	}
17.
18.	/* metoda getToken()
19.	 * získá token z proudu. Vloží jednu ze čtyř konstant 
20.	 * (TT_WORD, TT_NUMBER, TT_EOL nebo TT_EOF) a hodnotu
21.	 * tokenu do objektu ttype.
22.	*/
23.	boolean getToken() {
24.		int t;
25.		boolean done = false;
26.		try {
27.			t = nextToken();
28.		} catch (IOException ioe) {
29.			System.err.println(
30.				"IO error on line "+ lineno() +": "+ ioe.getMessage());
31.			return false;
32.		}
33.		return true;
34.	}
35.
36.	QuadFileParser(Reader r) {
37.		super(r);
38.		setup();
39.	}
40.}

Tokenizer pro loader QUAD souborů by mohl být jednodušší. Například metoda nextToken() kořenové třídy (čili StreamTokenizer) mohla být použita bez "rozšíření" metodou getToken(). Metoda getToken() přidává zachycování výjimek a jejich reportování v této vrstvě. Také metoda printToken(), primárně určená pro ladění, by mohla být považována za zbytečnou.

Pokud byste zde uvedený kód použili ke psaní svého vlastního formátu souborů, asi byste prvně změnili metodu setup() tak, aby byla vhodná pro váš formát. Také mějte na paměti že StreamTokenizer nerozpozná vědeckou notaci (systém vyjdáření čísel pomocí dekadických exponentů) a tudíž vrací pouze číselné hodnoty typu double.

Když máme dokončený tokenizer, přesuneme se ve stavbě loaderu o vrstvu výše k objektu.

Implementace vrstvy objekt

Účel této vrstvy je převést proud tokenů z tokenizeru na grafické objekty. V tomto případě je to jednoduché v tom, že prakticky existuje jen jeden druh grafického objektu, a tím je geometrie složená z čtyřúhelníků. Avšak jistá míra komplexity zde pořád přetrvává. Jedna potíž vyvstává z toho že není známo kolik čtyřúhelníků existuje. O tom bude dikuze později. Nyní se podívejme na implementaci.

Objektová vrstva je implementována jako SimpleQuadObject. Následující tabulka obshuje seznam metod třídy SimpleQuadObject.

Cílem této třídy / vrstvy je složit tokeny do grafických objektů. V tomto případě jsou grafické objekty to stejné co vertexy. Kolekce vertexů je vložena do objektu ArrayList (deklarovaného na řádku v následující ukázce kódu). Použití objektu ArrayList umožňuje měnit velikost za běhu. Ve scéně bude seznam polí převeden na pole a to pak na geometrický objekt.

Kdyby měla být tato třída rozšiřitelná, měli by zde být chráněné členy. Jediný člen v této třídě je flags. V kódu však není použit a byl ponechán jako příklad kde by byly použity datové členy při deklaraci více vrstev.

Ukázka kódu níže obsahuje většinu z implementace objektové vrstvy tohoto loaderu. Samozřejmě kompletní implementaci najdete v .jar souboru.

1. import QuadFileParser;
2. // ostatní příkazy import
3.
4. public class SimpleQuadObject {
5.	protected int flags;
6.	protected int fileType;
7.	// konstanty indikující typ souboru
8.	protected static final int COORDINATE = GeometryArray.COORDINATES;
9.	// seznam bodů které jsou čteny z .quad souboru do tohot pole
10.
11.	protected ArrayList coordList; // obsahuje Point3f
12.	// readVertex() načítá souřadnice vertexu
13.	boolean readVertex(QuadFileParser qfp) {
14.		Point3f p = new Point3f;
15.		qfp.getToken();
16.		if (qfp.ttype == qfp.TT_EOF)
17.			return false;
18.		p.x = (float) qfp.nval;
19.		qfp.getToken();
20.		p.y = (float) qfp.nval;
21.		qfp.getToken();
22.		p.z = (float) qfp.nval;
23.		// vložíme vertex do pole
24.		coordList.add(p);
25.		return true;
26.	}
27.
28.	// readQuad() načítá čtyři vertexy správného typu
29.	// (kterým jsou v této verzi jen souřadnice)
30.	boolean readQuad(QuadFileParser qfp) {
31.		int v;
32.		boolean result = false;
33.		for (v = 0; v < 4; v++)
34.			result = readVertex(qfp);
35.		return result;
36.	}
37.	
38.	// readFile() čte ze souboru data modelu
39.	void readQuadFile(QuadFileParser qfp) {
40.		ověříme typ souboru
41.		qfp.getToken();
42.		if (qfp.sval.equals("QUAD") || qfp.sval.equals("POLY"))
43.			fileType = COORDINATE;
44.		else throw new ParsingErrorException("Bad file type: "+ qfp.sval);
45.		// načteme vertexy
46.		while (readQuad(qfp));
47.	}
48. }

Kdyby existovaly ostatní informace o vertexu (vektory povrchových normál, barva, souřadnice textury) které by se daly načíst ze souboru, použily by se pro uložení těchto informací další objekty ArrayList. Tyto informace by také byly převedeny do polí a ve scéně aby se mohly vytvořit odpovídající geometrické objekty.

Je to právě tahle vrstva kde se zpracovává nejvíce informací formátu souborů. Pokud byste psali vás vlastní loader, museli byste implementovat všechny metody potřebné pro čtení různých dat ze souboru.

V této fázi je objektová vrstva hotová. Když máme dokončenou objektovou vrstvu, přesuneme se ve stavbě loaderu o vrstvu výše, ke scéně.

Implementace vrstvy scény

Tato vrstva je implementována ve třídě SimpleQuadScene. Následující tabulka obsahuje seynam metody třídy SimpleQuadScene.

1. class SimpleQuadScene extends SimpleQuadObject {
2.	// coordList je převedeno na pole pro vytvoření geometrie
3.	private Point3f[] coordArray = null;
4.
5.	private Point3f[] objectToPoint3fArray(ArrayList in) {
6.		Point3f[] out = new Point3f[in.size()];
7.		for (int i = 0; i < in.size(); i++)
8.			out[i] = (Point3f) in.get(i);
9.
10.		return out;
11.	}
12.
13.	private SceneBase makeScene() {
14.		// Vytvoří objekt Scene který navrací
15.		SceneBase scene = new SceneBase();
16.		BranchGroup group = new BranchGroup();
17.		scene.setSceneGroup(group);
18.		// model bude tvořen jedním objektem Shape3D
19.		Shape3D shape = new Shape3D();
20.		coordArray = objectToPoint3fArray(coordList);
21.		QuadArray qa = new QuadArray(coordArray.length, fileType);
22.		qa.setCoordinates(0, coordArray);
23.		// vložíme geometrii do objektu Shape3D
24.		shape.setGeometry(qa);
25.		group.addChild(shape);
26.		scene.addNamedObject("no name", shape);
27.		return scene;
28.	}
29.	
30.	public Scene load(Reader reader) throws FileNotFoundException,
31.						IncorrectFormatException,
32.						ParsingErrorException {
33.		// objekt QuadFileParser provede lexikální analýzu
34.		QuadFileParser qfp = new QuadFileParser(reader);
35.		coordList = new ArrayList();
36.		readQuadFile(qfp);
37.		return makeScene();
39.	}
40. }

Tato implementace loaderu je tak jednoduchá jak jen může být. Metoda makeScene() přebírá geometrii z QUAD souboru a vytváří z ní jeden objekt QuadArray. Tento objekt je vložen do objektu Shape3D a ten následně do scény.

Je to právě tato vrstva kde lze implementovat mnoho "pokročilých funkcí" loaderu zmiňovaných v sekci 3.4.1 "Co loadery dělají". Například lze do této vrstvy přidat stripifikaci a generování vektorů povrchových normál předáním souřadnic objektu GeometryInfo (viz sekce 3.2).

Pro tuto ukázku jsme udělali vše co bylo nezbytné a nyní se můžeme přesunout o vrstvu výše, k souboru.

Implementace vrstvy souboru

Vrstva souboru loaderu je jednoduchá. Většina kódu je přesně to samé co kód pro ObjectLoader poskytovaný pomocnými balíčky Java 3D API. Autor loaderu by se klidně mohl vyhnout použití tohoto kódu nebo napsání podobného kódu použitím třídy LoaderBase diskutované v sekci 3.3.3.

Vrstva souboru je implementována jako SimpleQuadFileLoader. Tato vrstva je obecná v tom smyslu, že neobsahuje nic, co by se přímo týkalo QUAD formátu. Také si všimněte že výsledná třída implementuje rozhraní Loader a že seznam metod třídy SimpleQuadFileLoader je stejný jako ten v přehledu k rozhraní Loader.

Implementace vrstvy souboru uzavírá konstrukci loaderu. Aplikace která používá tento loader se jmenuje SimpleQuadLoad.