So lassen sich mit Java-3D Grafikanwendungen erstellen

Die Java-3D-API ermöglicht das Entwickeln von Applikationen, die optisch äußerst realistisch wirken. Der Artikel erläutert detailliert die Funktionsweise von Java-3D und liefert anschauliche Beispiele.

Seit Version 1.2 wird Java-3D im Rahmen des Java Community Process^[1] entwickelt. Java-3D setzt auf OpenGL und Direct3D auf. Gleichzeitig ist es eine Schnittstelle, die Grafikprogrammierung mittels eines echten objektorientierten Konzepts ermöglicht. Darüber hinaus bietet Java-3D auch umfangreiche Unterstützung für 3D-Sound.

Zur Konstruktion einer Szene wird ein Szenengraph eingesetzt. Er repräsentiert die darzustellenden Objekte. Ein solcher Szenengraph ist wie ein Baum strukturiert, der eine Reihe von Elementen enthält, die zur Anzeige der Objekte notwendig sind.

So funktioniert die 3D-Welt

Der Aufbau von Java-3D unterscheidet sich deutlich von anderen gängigen 3D-Grafik-APIs wie OpenGL oder Direct3D. Dies sind prozedurale Low-Level-APIs, die eng mit der 3D-Hardware verbunden sind. Bei Java-3D richtet man hingegen sämtliche Grafikobjekte (auch Geometrieobjekte genannt) in einem sogenannten Szenengraphen ein. Dieses hierarchische Modell enthält alle Informationen über die darzustellenden Objekte und ihre Bearbeitung. Anschließend wird der Szenengraph zum Rendern an Java-3D übergeben. Für die Darstellung der Daten muss keinerlei Code geschrieben werden - das erledigt Java-3D. Mittels der zahlreichen leistungsfähigen integrierten Werkzeuge kann der Entwickler gleich auf einer höheren Ebene programmieren.

Java-3D nutzt dabei jede 3D-Beschleunigung, die die Grafikkarte bereitstellt. Letztlich erzeugt Java-3D OpenGL-Aufrufe in einer JNI-Schicht, die von der Grafikkarte beschleunigt werden können. Mit OpenGL beschleunigte Karten sind inzwischen in vielen Rechnern Standard. Deshalb sollten die Java-3D-Programme in der Regel hardwarebeschleunigt sein.

Bei dreidimensionalen Koordinaten (x,y,z) gibt die z-Komponente die Entfernung zum Betrachter an. Java-3D verwendet z-Werte, um nicht sichtbare Flächen verdeckter Objekte zu entfernen. Die z-Werte des roten Ringes im folgenden Bild sind klein, weil er sich dicht am Betrachter befindet. Er verdeckt Teile des blauen Ringes, wenn die z-Werte der beiden Ringe während des Renderns verglichen werden.

Ein 3D-Objekt enthält eine Sammlung von Koordinaten, die zusammen gerendert wurden. Die Klasse der Stammfunktionen (Primitive class) ist eine abstrakte Klasse für Geometrieobjekte, die als einfache Bausteine in Szenengraphen verwendet werden können. Java-3D bringt vier praktische Unterklassen der Stammfunktionen mit: Kugel (Sphere), Quader (Box), Kegel (Cone) und Zylinder (Cylinder). Mit ihnen lassen sich problemlos einfache Objekte erstellen, ohne viele Daten anzugeben. Bei der Kugel-Klasse gibt man beispielsweise einfach den Radius an, und alle Scheitelpunkte werden automatisch berechnet.

Will man ohne die Stammfunktionen-Klassen arbeiten, muss die Shape3D-Klasse verwendet werden, um alle Scheitelpunkte anzugeben. Die Daten lassen sich in Gestalt von Dreiecken, Vierecken, Linien oder Punkten spezifizieren. Die geometrische Repräsentation einer Kugel würde zum Beispiel als polygonales Netz definiert, üblicherweise mithilfe von Bändern aus miteinander verbundenen Dreiecken oder Vierecken.

Zumindest muss jeder Scheitelpunkt einen Ortswert (Koordinate) aufweisen. Zusätzlich zu den Ortswerten kann man noch weitere Elemente für jeden Scheitelpunkt angeben, etwa einen Farbwert, einen Normalvektor oder Texturkoordinaten. Normalvektoren finden für Beleuchtungseffekte Verwendung. Texturkoordinaten kommen zum Einsatz, um Texturen per Texturmapping auf einer Oberfläche darzustellen. Jeder Scheitelpunkt kann auch einen Alpha-Wert haben (für die Transparenz), der zusammen mit seiner Farbe angegeben wird. Bei Verwendung der Stammfunktionen-Klassen werden die Scheitelpunktvektoren und die Texturkoordinaten automatisch erzeugt.

Obwohl sich eine ganze Menge Daten mit jedem Scheitelpunkt speichern lässt, werden viele Grafikeffekte mithilfe des Appearance-Objekts erzeugt. Dieses Objekt beschreibt die allgemeinen Attribute der Oberfläche eines Gegenstandes. Jedes Shape3D- und Stammfunktionen-Objekt verfügt über sein eigenes Appearance-Objekt. Jedes Appearance-Objekt enthält wiederum eine Reihe von Attribut-Objekten. So kann ein Appearance-Objekt beispielsweise sowohl ein ColoringAttributes-Objekt als auch ein RenderingAttributes-Objekt enthalten.

Wie funktionieren Transformationen, Lichteffekte und Texturierungen?

Wenn die Objekte fertig sind und dargestellt werden sollen, lassen sie sich mittels 3D-Transformationen bewegen und skalieren, also im Prinzip animieren. Ort, Richtung, und Orientierung der Ansicht bezeichnet man als Viewpoint. Transformationen werden als Matrizen angegeben, und zwar in der leistungsfähigen Transform3D-Klasse. Transform3D bringt zahlreiche Hilfsfunktionen mit, um gängige Transformationen festzulegen, etwa Translationen, Rotationen oder Skalierungen.

Die Methode setTranslation(Vector3f trans) führt eine Translation eines Objekts durch, verschiebt es also. Dazu werden die Translationswerte dieser Transformation durch die x-, y- und z-Werte im trans-Argument ersetzt. Die Methode setScale(double scale) legt den Skalierungsfaktor der Transformation fest. Diese Funktion dient zur Größenveränderung eines Objekts. Die Methode rotX(double angle) stellt die Rotationskomponente auf eine Drehung gegen den Uhrzeigersinn um die x-Achse ein.

Zusätzlich zur Auswahl der Objekte innerhalb der Szene lässt sich ihre Darstellung auch über Beleuchtungseffekte steuern. Man kann die Art des Beleuchtungseffekts, etwa ein Spotlight, und die Farbe des Lichts angeben. Ebenso sind Nebeleffekte und automatische Verhaltensweisen der Objekte möglich.Texturmapping (häufig auch als "Tapezieren" bezeichnet) verleiht einer Szene eine realistischere Darstellung. So lässt sich beispielsweise das Bild einer Holzmaserung auf die Oberfläche eines Objekts abbilden, um einen Eichentisch zu simulieren. Beim Einsatz von Texturmapping muss man angeben, welches Bild verwendet und wo es auf dem Objekt angebracht werden soll. Ebenso sind Angaben nötig, was zu tun ist, wenn das Bild nicht genau passt, etwa bei der Abbildung eines rechteckigen Bildes auf einem nicht rechteckigen Polygon. Java-3D hat das Verfahren zum Laden von Texturbildern vereinfacht. Die TextureLoader-Klasse ist Bestandteil der Utility-Klassen von Java-3D.

TextureLoader texLoader = new TextureLoader(url,imageobserver)
appearance.setTexture(texLoader.getTexture());

Um ein realistisches Aussehen zu erzielen, sollten Länge und Breite des Texturbildes immer auf ein Vielfaches von 2 eingestellt werden. Andere Werte führen dazu, dass TextureLoader die Textur verzerrt.

Lichtquellen kommen zum Einsatz, um die Geometrieobjekte in einer Szene zu beleuchten. Es gibt vier Arten von Lichtquellen, sämtliche Unterklassen der abstrakten Light-Klasse. Alle Lichtquellen haben einen Farbwert und ein Ein/Aus-Bit. Ihr Bounding-Objekt beschreibt, welche Bereiche der Szene beleuchtet werden. In der realen Welt beleuchten meist mehrere Lichtquellen einen Gegenstand. Sonnenlicht und eine Deckenlampe haben beispielsweise Einfluss auf Farbe und Erscheinung der Objekte in einem Zimmer. In Java-3D lassen sich realistische Beleuchtungseffekte mithilfe mehrerer Lichtquellen simulieren. Folgende Arten von Lichtquellen können in einer Anwendung verwendet werden:

• Ein AmbientLight ist überall in der Szene. Dieses Umgebungslicht hat keinen bestimmten Ursprung und strahlt auch nicht in eine bestimmte Richtung.
• Ein PointLight strahlt von einem bestimmten Punkt aus in alle Richtungen und wird mit zunehmender Entfernung immer schwächer. Ein Beispiel für ein solches Punktlicht wäre eine Schreibtischlampe ohne Lampenschirm.
• Ein SpotLight ist ein spezielles Punktlicht, das auf einen Lichtkegel beschränkt ist, etwa eine Taschenlampe.
• Ein DirectionalLight leuchtet in eine bestimmte Richtung, geht aber nicht von einem bestimmten Punkt aus. Alle Lichtstrahlen einer gerichteten Lichtquelle sind parallel ausgerichtet. Theoretisch ist die Sonne ein Punktlicht, aber sie kann mit Hilfe eines DirectionalLight imitiert werden.

Die Teekanne im folgenden Bild weist Umgebungslicht auf - man kann sehen, dass die Rückseite etwas heller ist -, und es gibt ein gerichtetes Licht, das auf die Vorderseite scheint. Beide Lichtquellen haben Auswirkungen auf die endgültige Farbe jedes Dreiecks auf der Oberfläche der Teekanne.

Materialeigenschaften beschreiben, wie ein Objekt Licht reflektiert. Wenn ein Objekt, aus Stammfunktionen oder über Shape3D, nicht über ein Material-Objekt in seinem Appearance-Objekt verfügt, wird es nicht beleuchtet, selbst wenn eine Lichtquelle angegeben wird.

Man muss ein Material-Objekt erstellen, darin eine Beleuchtung ermöglichen und das Material-Objekt dem Appearance-Objekt hinzufügen. Das Material-Objekt ist eine von mehreren Attributsmengen, die im Appearance-Objekt enthalten sind.

Um besser zu verstehen, wie Materialeigenschaften sich auf die Erscheinung eines Objekts auswirken, kann man sich zum Beispiel einen glänzenden Rubin auf einem roten Teppich vorstellen. Beide sind zwar rot, aber sie reflektieren das Licht unterschiedlich: Der Rubin wird dort hell funkeln, wo er das Licht reflektiert, während der Teppich das Licht eher streut. Um diesen Unterschied Java-3D zu vermitteln, bekommt der Rubin einen hohen Wert für den Glanz im Material-Objekt, der Teppich einen sehr niedrigen Wert.

Eine Oberflächennormale ist ein Vektor, der am Scheitelpunkt senkrecht zur Oberfläche steht und die Ausrichtung der Oberfläche an diesem Punkt repräsentiert. Beim Berechnen von Beleuchtungseffekten beeinflusst die Oberflächennormale die Lichtreflexion einer Oberfläche.

Oberflächennormalen und Betrachterposition bestimmen, wo das glänzende Funkeln, also die Spiegelung, sich auf einer Kugel befindet. Es ist sehr erfreulich, dass die Stammfunktionen-Klassen die Oberflächennormalen automatisch erzeugen. Ein Java-3D-Szenengraph ist ein Baum mit zwei Teilen beziehungsweise Ästen: Ansicht und Inhalt. Der Ansichtsteil enthält alle technischen Details des komplexen Java-3D-Modells und definiert den Blickwinkel. Der Inhaltsteil beschreibt, was in der Szene zu sehen ist. Er enthält alle Grafikobjekte, etwa Kugeln, Quader und kompliziertere Geometrieobjekte, sowie die Transformationen, mit denen diese bewegt werden, also Lichtquellen, Verhaltensweisen, Gruppenknoten oder Nebel. Für die meisten einfachen Anwendungen lassen sich die Universe-Utility-Klassen verwenden, von denen die SimpleUniverse-Klasse die interessanteste ist.

Der folgende Quellcode erzeugt einen Szenengraph mit den Zylindern für die Achse und drei Kegeln. Dann wird ein weiterer Kegel hinzugefügt, der erst rotiert und dann verschoben wird. Ein anderer Kegel wird umgekehrt erst verschoben und dann gedreht.

import java.applet.Applet; import java.awt.BorderLayout; import java.awt.event.*; import java.awt.*; import java.awt.GraphicsConfiguration; import com.sun.j3d.utils.applet.MainFrame; import com.sun.j3d.utils.geometry.*; import com.sun.j3d.utils.universe.*; import javax.media.j3d.*; import javax.vecmath.*; import com.sun.j3d.utils.behaviors.vp.*; public class TransformOrder extends Applet { public static final int X =1; public static final int Y =2; public static final int Z =3; public static final int ROTATE_TOP =4; public static final int TRANSLATE_TOP =5; public static final int NO_TRANSFORM =6; private SimpleUniverse universe ; private BranchGroup scene; private Canvas3D canvas; private BoundingSphere bounds = new BoundingSphere(new Point3d(0.0, 0.0, 0.0), 1000.0); private Appearance red = new Appearance(); private Appearance yellow = new Appearance(); private Appearance purple = new Appearance(); Transform3D rotate = new Transform3D(); Transform3D translate = new Transform3D(); public void setupView() { /** einige auf den Ansichtszweig bezogene Dinge zur entsprechenden Seite des Szenengraphen hinzufügen */ // Mausinteraktion zur ViewingPlatform hinzufügen OrbitBehavior orbit = new OrbitBehavior(canvas, OrbitBehavior.REVERSE_ALL|OrbitBehavior.STOP_ZOOM); orbit.setSchedulingBounds(bounds); ViewingPlatform viewingPlatform = universe.getViewingPlatform(); // Damit wird die ViewingPlatform etwas zurückgesetzt, // so dass man die Objekte in der Szene sehen kann. viewingPlatform.setNominalViewingTransform(); viewingPlatform.setViewPlatformBehavior(orbit); } // beide Äste des Graphen erstellen, Ändern der Reihenfolge, in der Kindelemente hinzugefügt werden // Da der Group-Knoten nur ein Elternelement haben kann, muss man // neue Translations- und Rotations-Gruppen-Knoten für jeden Ast erstellen. Group rotateOnTop(){ Group root=new Group(); TransformGroup objRotate = new TransformGroup(rotate); TransformGroup objTranslate = new TransformGroup(translate); Cone redCone= new Cone(.3f, 0.7f, Primitive.GENERATE_NORMALS, red); root.addChild(objRotate); objRotate.addChild(objTranslate); objTranslate.addChild(redCone); // roten Kegel hinzufügen return root; } Group translateOnTop(){ Group root=new Group(); TransformGroup objRotate = new TransformGroup(rotate); TransformGroup objTranslate = new TransformGroup(translate); Cone yellowCone= new Cone(.3f, 0.7f, Primitive.GENERATE_NORMALS, yellow); root.addChild(objTranslate); objTranslate.addChild(objRotate); objRotate.addChild(yellowCone); // gelben Kegel hinzufügen return root; } Group noTransform(){ Cone purpleCone= new Cone(.3f, 0.7f, Primitive.GENERATE_NORMALS, purple); return purpleCone; } /** Eine Achse mit Hilfe der Zylinder-Primitive darstellen. Zylinder ist an der y-Achse ausgerichtet, so dass man ihn rotieren muss, wenn man die x- und z-Achse erstellt. */ public TransformGroup createAxis(int type) { // appearance und lightingProps werden für // Beleuchtung verwendet. Jede Achse hat eine andere Farbe. Appearance appearance = new Appearance(); Material lightingProps = new Material(); Transform3D t = new Transform3D(); switch (type) { case Z: t.rotX(Math.toRadians(90.0)); lightingProps.setAmbientColor(1.0f,0.0f,0.0f); break; case Y: // keine Rotation erforderlich, da der Zylinder bereits an der y-Achse ausgerichtet ist lightingProps.setAmbientColor(0.0f,1.0f,0.0f); break; case X: t.rotZ(Math.toRadians(90.0)); lightingProps.setAmbientColor(0.0f,0.0f,1.0f); break; default: break; } appearance.setMaterial(lightingProps); TransformGroup objTrans = new TransformGroup(t); objTrans.addChild( new Cylinder(.03f,2.5f,Primitive.GENERATE_NORMALS,appearance)); return objTrans; } /** x-, y- und z-Achse sowie drei Kegel erstellen. Plus einige Beleuchtungseffekte, um die Szene besser darzustellen. */ public BranchGroup createSceneGraph() { // Wurzel des Ast-Graphen erstellen BranchGroup objRoot = new BranchGroup(); // 45°-Rotation um die x-Achse rotate.rotX(Math.toRadians(45.0)); // Translation entlang der y-Achse translate.setTranslation(new Vector3f(0.0f,2.0f,1.0f)); // SCD 0.0f)); // Material-Objekte beziehen sich auf die Beleuchtung, // dazu später mehr Material redProps = new Material(); redProps.setAmbientColor(1.0f,0.0f,0.0f); // roter Kegel red.setMaterial(redProps); Material yellowProps = new Material(); yellowProps.setAmbientColor(1.0f,1.0f,0.0f); // gelber Kegel yellow.setMaterial(yellowProps); Material purpleProps = new Material(); purpleProps.setAmbientColor(0.8f,0.0f,0.8f); // violetter Kegel purple.setMaterial(purpleProps); // x-, y- und z-Achse und dann drei Kegel-Äste erstellen objRoot.addChild(createAxis(X)); objRoot.addChild(createAxis(Y)); objRoot.addChild(createAxis(Z)); objRoot.addChild(noTransform()); // violetter Kegel objRoot.addChild(rotateOnTop()); // roter Kegel objRoot.addChild(translateOnTop()); // gelber Kegel // ein paar Lichtquellen hinzufügen, damit nicht alles // im Dunkeln bleibt Color3f lightColor = new Color3f(.3f,.3f,.3f); AmbientLight ambientLight= new AmbientLight(lightColor); ambientLight.setInfluencingBounds(bounds); objRoot.addChild(ambientLight); DirectionalLight directionalLight = new DirectionalLight(); directionalLight.setColor(lightColor); directionalLight.setInfluencingBounds(bounds); objRoot.addChild(directionalLight); return objRoot; } public TransformOrder() { } public void init() { BranchGroup scene = createSceneGraph(); setLayout(new BorderLayout()); GraphicsConfiguration config = SimpleUniverse.getPreferredConfiguration(); canvas = new Canvas3D(config); add("Center", canvas); // eine einfache Szene erstellen und diese dem virtuellen Universum hinzufügen universe = new SimpleUniverse(canvas); setupView(); universe.addBranchGraph(scene); } public void destroy() { universe.removeAllLocales(); } // // Der folgende Code ermöglicht, dass TransformOrder als Anwendung // und als Applet ausgeführt werden kann // public static void main(String[] args) { new MainFrame(new TransformOrder(), 256, 256); } }

Hinweis: Dies ist Applet-Code, der im Applet-Viewer oder in einem Internetbrowser angezeigt werden kann. Das Programm lässt sich aber auch ganz einfach in eine selbstständige Anwendung konvertieren.

Weitere Informationen zu Java-3D:

• Java-3D-API-Spezifikation^[2]
• Java-3D-Anleitungen^[3]
• Java-3D-Community-Website^[4]

URLs in diesem Artikel:
[1] = http://jcp.org/en/home/index
[2] = http://java.sun.com/products/java-media/3D/reference/api/index.html
[3] = http://www.java3d.org/
[4] = http://www.j3d.org/