Żeby skorzystać z którejś z bibliotek, należy najczęściej pobrać jej kod źródłowy, a następnie skompilować go, przy pomocy jednego z wybranych wcześniej środowisk programistycznych. Zazwyczaj, rozwijające się, otwarte projekty, udostępniają najnowszą wersję swojego kodu źródłowego na serwerze SVN – w dalszej części zaprezentowany zostanie przykładowy kod dla aplikacji stworzonej przy pomocy Away3D (link).

Po skonfigurowaniu środowiska, należy utworzyć nowy projekt ActionScript 3.0 i podać ścieżkę do biblioteki Away3D. Kod potrzebny do stworzenia prostej sceny przedstawiającej szkielet trójwymiarowej kuli wymaga napisania kilku linijek. Przede wszystkim należy zaimportować elementy biblioteki Away3D oraz Flash. Następnie ustawiamy scenę i inicjujemy PaperVision3D, z którego wywodzi się biblioteka Away3D. Łączymy nowo utworzoną scenę, kamerę oraz widok, który następnie odpowiednio ustawiamy. W obrębie sceny tworzymy materiał, po czym tworzymy kulę zbudowaną z tego materiału. Umieszczamy kulę na scenie. Ostatnie linijki zawierają polecenie wygenerowania obrazu.

        1     package {
        2     import away3D.cmeras.Camera3D;
        3     import away3D.containers.Scene3D;
        4     import away3D.containers.View3D;
        5     import away3D.core.base.Vertex;
        6     import away3D.materials.WireColorMaterial;
        7     import away3D.materials.WireframeMaterial;
        8     import away3D.primitives.LineSegment;
        9     import away3D.primitives.Sphere;
        10    import flash.display.Sprite;
        11    import flash.display.StageAlign;
        12    import flash.display.StageScaleMode;
        13    import flash.events.Event;
        14    public class Example001 extends Sprite {
        15    private var scene:Scene3D;
        16    private var camera:Camera3D;
        17     private var view:View3D;
        18     public function Example001() {
        19      // ustawiamy scene
        20      stage.align = StageAlign.TOP_LEFT;
        21      stage.scaleMode = StageScaleMode.NO_SCALE;
        22      // inicjujemy Papervision3D
        23      init3D();
        24      // tworzymy obiekt 3D
        25      createScene();
        26      // inicjujemy Event loop
        27      this.addEventListener(Event.ENTER_FRAME, loop);
        28     }
        29     private function init3D():void {
        30      // tworzymy nową scenę
        31      scene = new Scene3D();
        32      // tworzymy kamerę i ustawiamy jej parametry
        33      camera = new Camera3D({zoom:20, focus:30, x:-100, y:-100, z:-500});
        34      // tworzymy widok
        35      view = new View3D({scene:scene, camera:camera});
        36      // centrujemy widok
        37      view.x = stage.stageWidth / 2;
        38      view.y = stage.stageHeight / 2;
        39         addChild(view);
        40     }
        41     private function createScene():void {
        42      // tworzymy materiał kuli
        43      var sphereMaterial:WireColorMaterial = new WireColorMaterial(0x000000,
        44        {wirecolor:0xFFFFFF});
        45      // tworzymy kulę ze zdefiniowanym wcześniej materiałem
        46      var sphere:Sphere = new Sphere({material:sphereMaterial, radius:50, segmentsW:10, segmentsH:10});
        47      // ustawiamy kulę w przestrzeni (domyślne współrzędne -[0, 0, 0])
        48      sphere.x = -100;
        49      scene.addChild(sphere)
        50     }
        51      private function loop(event:Event):void {
        52      // generujemy scenę
        53      view.render();
        54      }
        55    }
        56  }

Jak widać, proces tworzenia trójwymiarowej sceny przy pomocy zewnętrznych bibliotek we Flashu nie jest tak bezpośredni i prostolinijny, jak przy pomocy wizualnych edytorów. Należy jednak pamiętać, że samo tworzenie i umieszczanie obiektu zamknęło się w czterech linijkach kodu – pozostała otoczka jest powtarzana w każdym nowym projekcie.

Wszystkie powyżej opisane rozwiązania dają sobie doskonale radę, jednak ich trzeci wymiar opiera się w głównej mierze na symulacji wyświetlania grafiki 3D w dwuwymiarowym środowisku Flash, do którego dodano perspektywę i projekcję (link) – dzięki temu płaski obiekt można przedstawić w przestrzeni. Niektórzy twórcy mówią w tym wypadku w 2.5D, albo „pocztówkach w przestrzeni”. Dodatkowo, wszystkie te efekty są generowane programowo, w wyniku czego szczegółowość obiektów i ilość elementów z których składa się scena są ograniczone. Jednak Adobe zapowiedziało, że w nowej wersji Flash Playera wszystko ulegnie – nareszcie dostępna będzie sprzętowa akceleracja grafiki.

• Away3d SVN: http://away3d.googlecode.com/svn/

Java 3D (link) jest darmowa biblioteka służącą do generowania obrazów 3D, która wykorzystuje graf sceny do organizacji wirtualnych obiektów, które są następnie rysowane na ekranie. Rozszerzenie to zostało zaprojektowane w taki sposób, aby moc obsłużyć zarówno wizualizacje prostych obiektów, jak i tworzenie zaawansowanych gier (link). Java 3D przede wszystkim zajmuje się logika aplikacji i uporządkowaniem trójwymiarowych obiektów, natomiast obraz generowany jest przy pomocy narzędzi niskiego poziomu – OpenGL lub Direct3D. Zastosowanie tych standardów umożliwia korzystanie z dobrodziejstw sprzętowej akceleracji (link). Ponadto biblioteka umożliwia obsługę wielu wyświetlaczy, programów cieniujących (programable shaders), a także dźwięku przestrzennego.

Należy pamiętać, że Java 3D, chociaż nie daje zupełnej kontroli nad samym procesem generowania obrazu, jest pełnokrwistym językiem programowania. Pozwala na wykorzystywanie zaawansowanych struktur danych i architektury obiektowej. Z jednaj strony daje to nieograniczone możliwości, z drugiej jednak, każda aplikacja obarczona jest charakterystycznym dla Javy narzutem w warstwie abstrakcji, który wzmaga się wraz ze wzrostem komplikacji programu. Na stronie domowej projektu dostępna jest pełną dokumentacja (link), można również znaleźć kilka oficjalnych tutoriali (link), chociaż całość zdaje się być odrobinę zapomniana i zaniedbana, o czym świadczyć może wiele niedziałających odnośników Przykładowy program z oficjalnego poradnika Java 3D (link) rysujący oświetloną kule.

        1     import com.sun.j3D.utils.geometry.*;
        2     import com.sun.j3D.utils.universe.*;
        3     import Javax.media.j3D.*;
        4     import Javax.vecmath.*;
        5     public class Ball {
        6       public Ball() {
        7         // tworzymy Wszechświat
        8         SimpleUniverse universe = new SimpleUniverse();
        9         // tworzymy strukturę, która będzie zawierać obiekty
        10        BranchGroup group = new BranchGroup();
        11        // tworzymy kulę i dodajemy ją do grupy obiektów
        12        Sphere sphere = new Sphere(0.5f);
        13        group.addChild(sphere);
        14        // tworzymy czerwone światło
        15        Color3f light1Color = new Color3f(1.8f, 0.1f, 0.1f);
        16        BoundingSphere bounds =
        17        new BoundingSphere(new Point3D(0.0,0.0,0.0), 100.0);
        18        Vector3f light1Direction = new Vector3f(4.0f, -7.0f, -12.0f);
        19        DirectionalLight light1
        20  	      = new DirectionalLight(light1Color, light1Direction);
        21        light1.setInfluencingBounds(bounds);
        22        group.addChild(light1);
        23        // ustawiamy widok w kierunku kuli
        24        universe.getViewingPlatform().setNominalViewingTransform();
        25        // dodajemy stworzoną grupę obiektów do Wszechświatu
        26        universe.addBranchGraph(group);
        27      }
        28      public static void main(String[]args) { new Ball(); }
        29      }

• Java 3D: http://java3d.java.net/
• Getting Started with the Java 3D API: http://java.sun.com/developer/onlineTraining/java3d/j3d_tutorial_ch1.pdf
• Java 3D Tutorial: http://www.java3d.org/tutorial.html

VRML był od początku tworzony z myślą o konkretnym celu – nawigacja w trójwymiarowym środowisko na wzór rzeczywistości wirtualnej. Posiada zatem pewne domyślnie zaimplementowane funkcje wspomagające interakcje z użytkownikiem i zapewniające większe „zanurzenie” w wirtualny świecie (większą imersję). Czujniki wykrywające kolizje, bliskości i widzialności obiektów, a także przeciągania (dragging – obiekt można przesuwać po scenie przy pomocy myszki). Zdarzenia uruchamiane mogą być w odpowiedzi na dane akcje (na przykład klikniecie w obiekt) lub kiedy użytkownik pojawi się w zdefiniowanym polu. Światy, w prosty sposób, wzbogacone być mogą również o efekty dźwiękowe, tło lub mgle (link).

Ponieważ VRML projektowany był jako „interfejs dla internetu” posiada pewne idee zaczerpnięte z HTML oraz pozwalające na jego integracje z tym językiem. Metafora hipertekstu realizowana jest tutaj poprzez odnośniki, które nie są tekstem, ale obiektami 3D. Po kliknięciu w taki obiekt użytkownik przenoszony jest do innego świata VRML (osobny plik .wrl) lub do dowolnej strony pod innym adresem URL. Podobnie jak pliki graficzne na stronie WWW, modele 3D mogą być przechowywane w osobnych plikach i „doładowywane” już w trakcie eksploracji sceny przez użytkownika. Większość przeglądarek VRML umożliwiało kilka typów nawigacji, miedzy innymi symulacje chodu (walk – poruszanie się jedynie w dwóch płaszczyznach) lub latania (fly – ruch możliwy w każdym z 3 kierunków).

Pliki VRML mają rozszerzenie .wrl, od angielskiego słowa world (świat) i kodowane powinny być w formacie UTF-8. Plik .wrl może zostać skompresowany aby zaoszczędzić miejsce – zyskuje wtedy rozszerzenie .wrl.gz. Pomimo tego, że VRML ma silne powiązania ze stronami internetowymi, jego struktura nie bazuje na znacznikach, tak jak w HTML. Składnia oparta jest na formacie Open Inventor, który służył jako podstawa do stworzenia VRML (link).

Najprostszy plik .wrl jaki możemy napisać i wyświetlić w przeglądarce, składa się z nagłówka, komentarzy oraz obiektów (tzw. węzłów).

1. #VRML V2.0 utf8
2. # Najprostszy plik VRML
3. Shape {
4. geometry Box {
5. size 1 1 1
6. }
7. appearance Appearance {
8. material Material { diffuseColor 1 0 0 }
9. }
10. }

Najprostszy plik VRML. W pierwszej linii nagłówek, druga linia zawiera komentarz. W pozostałej części pliku zdefiniowany jest czerwony prostopadłościan.

W pierwszej linijce musi znajdować się nagłówek informujący przeglądarkę, że ma do czynienia z plikiem w formacie VRML. Linia nagłówka, podobnie jak komentarze, rozpoczynają się od znaku #. Nic co znajduje się miedzy tym znakiem, a końcem linii, nie jest przetwarzane przez przeglądarkę.
W dalszej części zdefiniowano czerwony prostopadłościan. Mamy zatem węzeł Shape, który charakteryzowany jest przez dwa węzły: geometry oraz appearance. Geometry Box nadaje mu kształt prostopadłościanu o wymiarach 1 na 1 na 1. VRML korzysta z prawoskrętnego ortogonalnego układu współrzędnych – poszczególne liczby określają rozmiar bryły w kierunku X, Y oraz Z. Przyjmuje się, że jednostka miary są metry, ale jest to jedynie konwencja, której nie wszyscy twórcy przestrzegają. Wymiary mogą być liczbami dziesiętnymi (możemy zapisać 1.0 1.0 1.0).
Węzeł appearance Appearance definiuje materiał z którego jest zrobiony prostopadłościan. Wybrano matowy kolor (diffuseColor) o wartościach wyrażonych w substraktywnym modelu RGB (czerwony, zielony, niebieski). Każda liczba odpowiada jednej składowej i może przyjmować wartości od 0.0 do 1.0.

Węzły w pliku VRML są ułożone hierarchicznie w grafie. Wiele programów i technologii związanych z tworzeniem grafiki trójwymiarowej korzysta z takiej struktury. Po pierwsze, taki sposób uporządkowania elementów ułatwia ich późniejsze odwzorowanie na niższym poziomie generowania obrazu (OpenGL, Direct3D). Po wtóre, ułatwia to kontrole nad obiektami w obrębie sceny.

Idea grafu sceny (scene graph) polega na tym, że każdy element znajdujący się wyżej w hierarchii, wpływa na elementy będące niżej. Należy zaznaczyć, że nie tylko widzialne elementy (bryły lub modele) mogą być częścią grafu, ale również transformacje i materiały. W ten sposób, jeśli jakiś obiekt składa się z kilku prostszych obiektów, nie ma potrzeby, aby każdemu z osobna nadawać te same cechy. Można umieścić node nadający takie cechy na szczycie grafu i będzie on wpływał na wszystkie podległe mu obiekty.

Wiedząc na czym polega „metafora” grafu, łatwiej będzie zrozumieć kolejny plik .wrl, w którym wygenerujemy proste trójwymiarowe drzewo z gałązką. Istotną nowością w tym kodzie jest węzeł Transform. Jest on odpowiedzialny za zmianę położenia układu współrzędnych względem którego rysowane są obiekty. Należy pamiętać, że w VRML bryły rysowane są „od środka”. Oznacza to tyle, że jeśli stworzymy sferę o promieniu 1, to jej środek będzie się znajdował w punkcie 0 0 0.

1. #VRML V2.0 utf8
2. #Zielona korona
3. Shape {
4. geometry Sphere { radius 1.5 }
5. appearance Appearance {
6. material Material { diffuseColor 0 1 0 }
7. }
8. }
9. #Brązowywy pień i gałązka
10. Transform {
11. translation 0 -2.5 0
12. children [
13. Shape {
14. geometry Cylinder {
15. radius 0.2
16. height 2.0
17. }
18. appearance Appearance {
19. material Material { diffuseColor 0.5 0.15 0.05 }
20. }
21. }
22. Transform {
23. translation -0.5 0.5 0
24. rotation 0 0 1 1.0472
25. children [
26. Shape {
27. geometry Cylinder {
28. radius 0.1
29. height 1.0
30. }
31. appearance Appearance {
32. material Material { diffuseColor 0.5 0.15 0.05 }
33. }
34. }
35. ]
36. }
37. ]
38. }

Kod VRML za pomocą którego wygenerować można trójwymiarowe drzewo.

Na początku rysujemy kulę o promieniu 1.5 jednostki (linia 4) i nadajemy jej kolor zielony (linie 5-6) – będzie mogła udawać koronę drzewa. Następnie, przesuwamy nasz układ współrzędnych o 2,5 jednostki wzdłuż osi Y (linia 12) i rysujemy cylinder (linie 14-17) o kolorze brązowym (linie 19-20), który służyć ma jako pień drzewa. Ponownie przesuwamy (linia 24) układ współrzędnych, ale tym razem dodajemy również obrót (linia 25) – pozwoli nam to narysować boczną gałąź (linie 26-33).

Boczna gałązka utworzona jest o 0,5 jednostki w lewo (czyli wzdłuż osi X) i o 0,5 jednostki do góry (w rozumieniu, wzdłuż osi Y), względem środka pnia. Dzięki takiemu powiązaniu – gdybyśmy obrócili cały pień – gałąź obróciłaby się samoczynnie w odpowiedni sposób. Gdyby gałąź była niezależnym obiektem – należałoby samemu zadbać o to, aby narysowana została we właściwym położeniu. Oczywiście, w rzeczywistym zastosowaniu, należałoby również koronę drzewa umieścić w węźle Transform, aby móc całość traktować jako jeden obiekt. Jednak na potrzeby tego modelu nie zrobiono tego, dla zwiększenia przejrzystości.

Mam nadzieję, że ten krótki przykład, pozwala zaprezentować, jak potężnym, a zarazem prostym narzędziem był VRML. Poza modelowaniem, pamiętać należy o mechanizmach wspomagających interaktywność oraz multimedialność. Bez zdolności programistycznych, ani specjalistycznych narzędzi, można było kreować świat, który mógł nie tylko efektownie wyglądać, ale również reagować na akcje użytkownika. Jeśli podstawowe możliwości nie wystarczały twórcom, mogli zawsze skorzystać z skryptów napisanych w językach wyższego programowania, które znacznie rozszerzały możliwości VRML. W tym znaczeniu, standard ten mógł przynieść grafikę 3D „pod strzechy”. Rzeczywistość okazała się jednak zgoła odmienna…

VRML, w zamyśle jego twórców, miał zrewolucjonizować sposób w jakim poruszamy się po internecie. Miał też umożliwić wymianę grafiki trójwymiarowej poprzez sieć i wykorzystanie jej do budowania multimedialnych, interaktywnych scen, które wyświetlić można na zwykłych komputerach osobistych. Standard miał być przystępny dla każdego, kto chciał się zająć tego typu twórczością, a prawdopodobnie było wielu takich ludzi, gdyż wirtualna rzeczywistość była tematem bardzo modnym i chodliwym w latach gdy powstawał VRML.

• VRML Interactive Tutorial: http://www.few.vu.nl/~eliens/mma1/@archive/interactive/toc.html
• VRML Primer and Tutorial: http://tecfa.unige.ch/guides/vrml/vrmlman/