3. Java 3D 3.1 Grundlagen - Hierarchie von Java-Klassen, die eine Schnittstelle zur Darstellung und Interaktion von dreidimensionalen grafischen Szenen bilden. - Die geometrischen Objekte werdenin einem Virtuellen Universum (Virtual Universe) erzeugt, welches dann gerendert wird. - Ein Java3D-Programm erzeugt Instanzen von Java3D-Objekten und platziert sie in eine Szenengraph- (Scene Graph-) Datenstruktur. - Szene-Graph: Ansammlung / Anordnung von 3D-Objekten in einer Baumstruktur. - Java 3D Programme: Realisierung als alleinstehende Applikationen und als Java Applets. - Relevante Links: http://java3d.j3d.org/ https://java3d.dev.java.net/ http://www.hs-fulda.de/caelabor java - Aktuelle Alternativen bezüglich 2D / 3D Grafik-API s: + DirectX -> Ursprünglich vordringlich für Spiele entwickelt + OpenGL -> universelle Grafik-Library -> Professioneller Einsatzbereich -> Rendering-Pipeline als HW-Lösung auf Grafikkarten + Java 3D (SUN Microsystems / JAVA3D.ORG) Bis Release 1.3.1: SUN Microsystems APIs auf DirectX oder OpenGL aufbauend Ab Release 1.3.2: Opensource-Projekt
Aktuelle Binaries: Version 1.5.2; download: https://java3d.dev.java.net/binary-builds.html + Visual Toolkit (VTK -> KITWARE) -> typ. auf Tcl/Tk, Java,..., aufbauend -> Professioneller Einsatzbereich, Open Source - Java 3D API Klassenhierarchie -> zwei Typen von Klassen: + Kernklassen (Basisklassen, "core classes") javax.media.j3d.* Package -> j3dcore.jar und j3daudio.jar mehr als 100 Klassen + Zubehörklassen ("utility classes") -> com.sun.j3d.utils.* Package -> dient der Erweiterung der elementaren Kernklassen; leistungsfähige Erweiterungen, z.b. content loader, simpleuniverse, geometry classes wie Boxen,..) - Ergänzende Java (Zubehör-) Klassen aus der Java-Entwicklungsumgebung: + Abstract Window Toolkit (AWT) Klassen (java.awt.*) zur Erzeugung eines 3D-Ausgabefensters (Alternative: Swing-Klassen -> javax.swing) + Vektormathematik-Klassen (javax.vecmath.*) für mathematische Objekte, z.b. Punkte, Vektoren, Matrizen, etc. - Bezugsquellen zu Java 2D/3D, Dokumentationen, Lizenzbedingungen, Installationsanweisungen,... -> vgl. vorstehend, relevante Links - Praktische Entwicklungsumgebung für Java: -> Eclipse, Gel, Joe,... - Java-Struktur (Quelle: SUN):
Java 3D API auf der Ebene der User Interface Toolkits 3.2 Der Szenengraph - Dient der Modellierung (Aufbau) des virtuellen Universums (virtual universe); wird aus Instanzen der Java3D-Klassen erzeugt - kann als Designtool und / oder Dokumentationsform für Java3D- Programme angesehen werden - Entspricht der typischen Baumstruktur mit Knoten und Kanten; + Knoten (nodes): Instanzen der Java 3D Klassen (Datenelemente) + Kanten (arcs): Beziehung zwischen Knoten. Folgende Alternativen: -> Vater-Kind Beziehung (Knoten -> Subknoten) -> Referenzbeziehung (Beziehung zwischen einem gewöhnlichen Knoten mit einer Knotenkomponente (note component) Achtung: Kanten verschiedener Knoten dürfen nicht auf gleichen Subknoten verweisen -> nur einen einzigen Weg vom Wurzelknoten zum Blattknoten (leaf) - Knotenkomponente (note component): Gibt u.a. Darstellungsattribute, etc., an.
- Fallbeispiel einen Szenegraphen: - Wurzel des Szenengraphen: Virtuelle Universum (virtual universe). - "Locale"-Objekt(e): Subknote(n) des virtual universe Bilden Ursprung in der 3D-Szene für den jeweils untergeordneten Teilbaum. Ein Szenengraph kann prinzipiell mehrere "Locales" enthalten (mehrere Koordinatensysteme). Dieses Beispiel ist jedoch nur auf ein solches Objekt beschränkt und diese Restriktion findet sich auch bei den meisten anderen Java 3D Applikationen. - Teilbaumgruppenknoten ("branch group nodes", BG): Sind den "Locale"-Objekten untergeordnet. + Teilbaumgraph ("branch graph") mit Teilbaumgruppenknoten (BG) als Wurzel. Achtung: Teilbaumgruppenknoten (BG) sind die einzigen Elemente, die unter einem "Locale" eingefügt werden dürfen. Ein "Locale" kann prinzipiell mehrere Teilbaumgruppenknoten enthalten. + Subknoten des Teilbaumgruppenknoten: hier ein Transformationsgruppenknoten (TG). + Diesem untergeordnet ist ein Blattknoten (leaf) und eine weitere Transformationsgruppe mit einem anderen Blattknoten.
Beispiel: Der erste Blattknoten entspricht in diesem Beispiel einem Planet (z.b. Erde), wobei die erste Transformationsgruppe z.b. die Position des Planeten im Raum angibt. Die gleiche Analogie gilt auch für den zweiten Blattknoten (z.b. Mond), wobei hier die zweite Transformation relativ zur übergeordneten Transformation berechnet wird. Also entspricht die Hierarchie im Szenengraphen genau der Hierarchie aus der Realität. Die Knotenkomponente: Definiert im Beispiel ein visuelles Attribut für das Planetobjekt, z.b. die Farbe des Planeten. Tabellarische Zusammenfassung der Ergebnisse des Fallbeispiels: Szenengraphknoten Möglicher Vaterknoten Mögliche Kinderknoten Beschreibung Virtuelles Universum - "Locales" Wurzel für die gesamte 3D- Szene "Locale" Virtuelles Universum Teilbaumgruppenknoten Ursprung für den untergeordneten Teilbaum Teilbaumgruppenknoten "Locale" andere (Gruppen-)Knoten Wurzel eines Teilbaumgraphen Blattknoten anderer Gruppenknoten - (Visuelles) Objekt der 3D- Szene Knotenkomponente - - (Visuelles) Attribut eines 3D-Objektes
3.3 Teilbaumgraphen Man unterscheidet zwei Arten von Teilbaumgraphen: - Inhalts-Teilbaumgraph ( content branch graph ) - Ansichts-Teilbaumgraph ( view branch graph ) content branch graph -> virtuelles Universum bzw. 3D-Szene. Dazu zählen u.a.: Geometrie, visuelle Attribute, Animationen, Transformationen, Sounds, Lichter usw. view branch graph: -> Ansichtsparameter der 3D-Szene, z.b. Position und Orientierung der sog. Szenenkamera bzw. des Betrachters der Szene. Man spricht in diesem Zusammenhang oft vom point of view oder eye point. Zusammenfassung beider Strukturen in einem Szenengraphen: Basisinformation für das Rendering-System zur Darstellung der 3D-Szene (vgl. Fallbeispiel in nachstehender Abbildung). Spezifiziert Kopf des Be- trachters der 3D-Szene beschreibt physikalische Umgebung, u.a.audioausgabe, Steuerung phys. Ein- und Ausgabegeräte
3.4 Java 3D Klassenhierarchie Klassenhierarchie des Java 3D API Packages javax.media.j3d.*: SceneGraphObject die Basisklasse für die meisten oder sogar fast alle Java 3D Kern- und Zubehörklassen. Das SceneGraphObject und seine Subklassen Zwei Subklassen: - Die Node-Klasse, bestehend aus Group- und Leaf-Klassen + entspricht den zuvor angesprochenen Gruppen- und Blattknoten. + werden häufig zur Bildung des Szenengraphen benutzt.
- Die NodeComponent-Klasse -> beschreibt eine Knotenkomponente des Szenengraphen. Übersicht über die Node-Klasse (und ihre Subklassen) sowie über die NodeComponent-Klasse: - Node + Basisklasse für Group und Leaf + Definiert einige wichtige Basismethoden, die in den abgeleiteten Klassen implementiert werden. Der Szenengraph wird aus diesen Node-Objekten konstruiert. - Group + Beschreibt die Gruppenknoten des Szenengraphen. + Dient als Basisklasse für weitere Subklassen, die z.b. die Position und Orientierung von visuellen Objekten in einer 3D-Szene angeben. Zwei dieser Subklassen sind die bereits beschriebenen Teilbaumund Transformationsgruppenknoten (in der grafischen Repräsentation des Szenengraphen werden diese Objekte durch Kreise mit einem "BG" bzw. "TG" angegeben). - Leaf + Blattknoten des Szenengraphen dar. + Kann zwar keine Subknoten enthalten, sich aber auf Knotenkomponenten beziehen. Ist Basisklasse für weitere Klassen, die 3D-Formen, Sounds und Verhalten ("behaviors") von visuellen Objekten in der 3D-Szene angeben. Beispiele: Shape3D, Light und Behavior (In der grafischen Repräsentation des Szenengraphen werden Shape3D-Objekte (d.h. also 3D-Formen) durch Dreiecke mit einem "S" dargestellt). - NodeComponent + Beschreibt eine Knotenkomponente des Szenengraphen. + Dient als Basisklasse für diverse andere Subklassen z.b. zur Festlegung von Geometrie, Darstellungsattributen, Texturund Materialeigenschaften von Shape3D-Objekten (siehe Leaf- Klasse).
3.5 Schema zur Erstellung von Java 3D-Programmen 3.5.1 Allgemeine Vorgehensweise 1. Erzeugung eines Canvas 3D-Objekts -> Ein Canvas 3D-Objekt definiert einen Fensterbereich, in dem die Ausgabe und ggf. Interaktion stattfinden soll und kann (vgl. AWT-Klasse) 2. Erzeugung eines VirtualUniverse-Objekts -> Wurzel des gesamten Szenengraphen 3. Erzeugung eines Locale-Objekts und dessen Hinzufügen (assoziieren) zum VirtualUniverse -> Dient als Ursprung für die untergeordneten Teilbäume 4. Erzeugen eines ViewBranchGraphen (Ansichts-Teilbaumgraphen) a) Erzeugen eines View-Objekts -> Enthält alle wichtigen Informationen, die zur Darstellung einer 3D-Szene von einem Blickpunkt (viewpoint) betrachtet notwendig sind b) Erzeugen eines ViewPlatform-Objekts -> Beschreibt Position, Orientierung und Skalierung des Betrachters (viewer) der 3D-Szene; Stichwort: Szenenkamera c) Erzeugen eines PhysicalBody-Objekts -> Spezifiziert Kopf des Betrachters der 3D-Szene, z.b. Ursprung des Koordinatensystems ( zwischen linkem und rechtem Auge ), Richtungen der x-, y- und z- Achsen beim Betrachter (vgl. glulookat bei OpenGL) d) Erzeugen eines PhysivalEnvironment-Objekts -> Beschreibung der physikalischen Umgebung; dient u.a. zur Steuerung physikalischer Eingabegeräte (Sensoren) und der Audio-Ausgabegeräte e) Hinzufügen der Viewplattform-, PhysicalBody-, PhysivalEnvironment- und Canvas 3D-Objekte zum View-Objekt 5. Erzeugen eines oder mehrerer ContentBranchGraphen 6. Kompilierung dieser Branchgraphen -> Dabei werden die Szenengraphelemente in eine für den Java 3D Renderer effizientere Form übersetzt -> Methode compile() Ziel: Beschleunigung der 3D-Ausgabe. Dazu zählt z.b. die Zusammenfassung von mehreren benachbarten Transformationsgruppen
7. Einfügen der Teilgraphen in das Locale-Objekt -> Mit diesem letzten Schritt sind der Szenengraph und alle weiteren erforderlichen Java 3D Objekte fertig konstruiert, so dass die 3D-Ausgabe jetzt erfolgen kann 3.5.2 Arbeiten mit der SimpleUniverse - Klasse Die meisten Java 3D Programme basieren auf dem gleichen Ansichts-Teilbaumgraphen (gleiche Kameraposition, etc.). -> Vereinfachung der beschriebenen allgemeinen Programmstruktur Einsatz derjava 3D Zubehör-Klasse SimpleUniverse -> Abdeckung der Schritte 2. - 4. aus der oben angegebenen Übersicht Schema zur Erstellung eines Java 3D-Programms bei Verwendung des SimpleUniverse 1. Erzeugung eines Canvas 3D-Objekts 2. Erzeugung eines SimpleUniverse-Objekts, Anpassen des SimpleUniverse-Objekts 3. Erzeugen des ContentBranchGraphen 4. Kompilierung des Branchgraphen 5. Einfügen des ContentBranchGraphen in das Locale-Objekt des SimpleUniverse -> Speziell für Java 3D Anfänger sinnvoll -> Einschränkung: Es kann und wird nur mit einem einzigen View gearbeitet Der SimpleUniverse-Konstruktor erzeugt einen Szenengraphen, einschließlich der VirtualUniverse- und Locale-Objekte, sowie den kompletten Ansichts- Teilbaumgraphen.
Szenengraphen bei Nutzung von SimpleUniverse: 3.6 Die Projektionsfläche Der Ansichts-Teilbaumgraph, der durch die SimpleUniverse-Klasse erzeugt wird, enthält die sog. Projektionsfläche ("image plate"). -> Entspricht Ebene, auf der das Bild der 3D-Szene projiziert wird Verdeutlichung der Beziehung zwischen der Projektionsfläche, Szenenkamera und den visuellen 3D-Szenenobjekten:
Die Szenenkamera befindet sich vor der Projektionsfläche, wobei die visuellen Objekte (die hinter der Fläche sind) darauf abgebildet werden. Standardmäßig -- > Ursprung des SimpleUniverse befindet sich im Punkt (0, 0, 0) -> auch das Zentrum der Projektionsfläche. Die Orientierungsrichtung ist dabei durch die Z-Achse beschrieben. Von diesem Zentrum betrachtet ist die X-Achse eine horizontale Gerade mit positiven Werten nach rechts und die Y-Achse eine vertikale Gerade mit positiven Werten nach oben. Bei Java 3D hat man sich darauf geeinigt, dass die Szenenkamera auf die Position (0, 0, 2.41) gesetzt wird und die Orientierungsrichtung durch die negative Z-Achse beschrieben wird. Man spricht hierbei von der sog. "nominal viewing transformation". Geeignete Methode der ViewingPlatform-Klasse: setnominalviewingtransform() -> setzt die nomonale Viewing-Distanz auf 2.41 m Um auf das ViewingPlatform-Objekt in der SimpleUniverse-Klasse zugreifen zu können, bedient man sich der folgenden Methode der SimpleUniverse-Klasse: ViewingPlatform getviewingplatform() Mit Hilfe der ViewingPlatform kann man die Position der Kamera verändern, indem man sich mit Hilfe der Methode TransformGroup getviewplatformtransform() die entsprechende TransformGroup holt und ihr eine selbst erzeugte Transfomations-Matrix zuweist.
Diese kann man sich mit der sehr praktischen Methode lookat(point3d eye, Point3d center, Vector3d up) der Klasse Transform3D erzeugen. Damit könnte der entsprechende Code folgendermaßen aussehen: // set the position of the eye point Transform3D l3d = new Transform3D(); l3d.lookat(new Point3d(0.8,1.4,4), new Point3d(0,0,0), new Vector3d(0,1,0)); l3d.invert(); simpleu.getviewingplatform(). getviewplatformtransform(). settransform(l3d);
3.7 Ein einfaches Java 3D - Programm /* * Copyright Lutz / Emmel, Verlag Harry Deutsch, 2000 * * Beispiel: ColorCubeA.java * * Realisierung eines farbigen Wuerfels * */ // Zu importierende Klassen import java.applet.applet; import java.awt.borderlayout; import com.sun.j3d.utils.applet.mainframe; import com.sun.j3d.utils.universe.simpleuniverse; import com.sun.j3d.utils.geometry.colorcube; import javax.media.j3d.*; public class ColorCubeA extends Applet { public ColorCubeA() { // Canvas 3D erzeugen setlayout(new BorderLayout()); // Standardkonfiguration bestimmen GraphicsConfiguration config = SimpleUniverse.getPreferredConfiguration(); Canvas3D canvas3d = new Canvas3D(config); add("center", canvas3d); /* der BranchGraph wird durch den Aufruf der Methode createscenegraph erzeugt */ BranchGroup scene = createscenegraph(); /* die Szene wird optimiert: Compilation der BranchGroup und der assoziierten Objekte durch Erzeugung und Speicherung eines compilierten Szenengraphe */ scene.compile(); // ein neues SimpleUniverse mit dem Canvas3D-Objekt wird erzeugt SimpleUniverse universe = new SimpleUniverse(canvas); // ein Default-Viewbranch wird erzeugt
universe.getviewingplatform().setnominalviewingtransform(); } // die Szene wird in das Universum eingesetzt universe.addbranchgraph(scene); public BranchGroup createscenegraph() { // Erzeugen eines BranchGroup-Objektes... BranchGroup objroot = new BranchGroup(); //. welches den ColorCube aufnimmt objroot.addchild(new ColorCube(0.4)); } return objroot; public static void main(string[] argv) { /* falls das Programm eine Anwendung ist, wird der folgende Programmcode benötigt */ new MainFrame(new ColorCubeA(), 256, 256); } } Java-Klassen im vorstehenden Beispiel (Quelle: SUN Java 3D API): a) Erzeugung eines Canvas3D-Objekts The Canvas3D class is derived from the Canvas class of the Abstract Windowing Toolkit (AWT). At least one Canvas3D object must be referenced in the viewing branch graph of the scene graph. For more information on the Canvas class, consult a reference on the AWT. Canvas3D Constructor Canvas3D(GraphicsConfiguration graphicsconfiguration) Constructs and initializes a new Canvas3D object that Java 3D can render given a valid GraphicsConfiguration object. It is an extension of the AWT Canvas class. For more information on the GraphicsConfiguration object see the Java 2D specification, which is part of the AWT in JDK 1.4.
b) Erzeugung des SimpleUniverse SimpleUniverse Constructors Package: com.sun.j3d.utils.universe This class sets up a minimal user environment to quickly and easily get a Java 3D program up and running. This utility class creates all the necessary objects for a view branch graph. Specifically, this class creates Locale, VirtualUniverse, ViewingPlatform, and Viewer objects (all with their default values). The objects have the appropriate relationships to form the view branch graph. SimpleUniverse provides all functionality necessary for many basic Java 3D applications. Viewer and ViewingPlatform are convenience utility classes. These classes use the View and ViewPlatform core classes. SimpleUniverse() Constructs a simple virtual universe. SimpleUniverse(Canvas3D canvas3d) Construct as simple universe with a reference to the named Canvas3D object. c) Realisierung des farbigen Würfels ColorCube Constructors Package: com.sun.j3d.utils.geometry A ColorCube is a simple color-per-vertex cube visual object with a different color for each face. ColorCube extends the Shape3D class; therefore, it is a Leaf node. ColorCube is easy to use when putting together a virtual universe. ColorCube() Constructs a color cube of default size. By default, a corner is located 1 meter along each of the axis from the origin, resulting in a cube that is centered at the origin and is 2 meters high, wide and deep. ColorCube(double scale) Constructs a color cube scaled by the value specified. The default size is 2 meters on an edge. The resulting ColorCube has corners at (scale, scale, scale) and (-scale, -scale, -scale). d) Compilation der BranchGroup und der assoziierten Objekte durch Erzeugung und Speicherung eines compilierten Szenengraphen void compile() Compiles the source BranchGroup associated with this object by creating and caching a compiled scene graph. Concepts of compiled and live are implemented in the SceneGraphObject class.
BranchGroup objects can be compiled. Compiling a BranchGroup converts the BranchGroup object and all of its ancestors to a more efficient form for the renderer. Compiling BranchGroup objects is recommended as the last step before making it live. It is best to only compile the BranchGroup objects inserted into Locales. e) Ablauffähiges Java-Programm realisieren Die Klasse HelloJava3Da wurde von der Oberklasse Applet abgeleitet. Ablauffähige Anwendung Ergänzung um Main-Programm Klasse Mainframe zur Erzeugung eines AWT-Frames (window) -> Ermöglichung des Ablauf eines Applets als Anwendung MainFrame Constructor (partial list) package: com.sun.j3d.utils.applet MainFrame makes an applet into an application. A class derived from applet may have a main() method which calls the MainFrame constructor. MainFrame extends java.awt.frame and implements java.lang.runnable, java.applet.appletstub and java.applet.appletcontext. MainFrame(java.applet.Applet applet, int width, int height) Creates a MainFrame object that runs an applet as an application. Parameters: applet the constructor of a class derived from applet. width the width of the window frame in pixels height the height of the window frame in pixels Auswahl von Tutorials (an der FH Fulda realisiert): - Blum/Wassermann: Aspekte in 2D und 3D. Interaktive Lernsoftware, FH FD, FB AI, WS 2001/2002 - Klug, M.: Lernprogramm für Java 3D. Ausarbeitung und Tutorial im Rahmen der LVA Systemprogrammierung, FH FD, FB AI, WS 2001 / 2002 - Pressmann, Julia: Seminar Java 3D (Beleuchtung und Material) Seminararbeit an der FH FD, FB AI, WS 2002/2003 - Pressmann, Julia: Java 3D Tutorium (Transformationen, Texturen) Ausarbeitung und Tutorial im Rahmen der LVA Systemprogrammierung, FH FD, FB AI, WS 2002/2003 Weitere Beispiele, etc. -> vgl. LVA