Java 3D - Hochschule Fulda

Prof. Dr. W. Heinzel, Hochschule Fulda, FB AI, Marquardstr. 35, 36039 Fulda
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
Prof. Dr. W. Heinzel, Hochschule Fulda, FB AI, Marquardstr. 35, 36039 Fulda
⇒ 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):
Prof. Dr. W. Heinzel, Hochschule Fulda, FB AI, Marquardstr. 35, 36039 Fulda
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 Java3DProgramme 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.
Prof. Dr. W. Heinzel, Hochschule Fulda, FB AI, Marquardstr. 35, 36039 Fulda
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.
Prof. Dr. W. Heinzel, Hochschule Fulda, FB AI, Marquardstr. 35, 36039 Fulda
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
Virtuelles Universum
"Locale"
Möglicher
Mögliche
Vaterknoten
Kinderknoten
-
Virtuelles
Universum
Teilbaumgruppenknoten
"Locale"
Blattknoten
anderer
Gruppenknoten
Knotenkomponente
-
"Locales"
Beschreibung
Wurzel für die
gesamte 3DSzene
Ursprung für
den
Teilbaumgruppenknoten
untergeordneten
Teilbaum
andere
(Gruppen-)Knoten
Wurzel eines
Teilbaumgraphen
-
(Visuelles)
Objekt der 3DSzene
-
(Visuelles)
Attribut eines
3D-Objektes
Prof. Dr. W. Heinzel, Hochschule Fulda, FB AI, Marquardstr. 35, 36039 Fulda
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-
beschreibt physikalische Umgebung,
trachters der 3D-Szene
u.a.Audioausgabe, Steuerung phys.
Ein- und Ausgabegeräte
Prof. Dr. W. Heinzel, Hochschule Fulda, FB AI, Marquardstr. 35, 36039 Fulda
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.
Prof. Dr. W. Heinzel, Hochschule Fulda, FB AI, Marquardstr. 35, 36039 Fulda
- 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 LeafKlasse).
Prof. Dr. W. Heinzel, Hochschule Fulda, FB AI, Marquardstr. 35, 36039 Fulda
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 zAchsen 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
Prof. Dr. W. Heinzel, Hochschule Fulda, FB AI, Marquardstr. 35, 36039 Fulda
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 AnsichtsTeilbaumgraphen.
Prof. Dr. W. Heinzel, Hochschule Fulda, FB AI, Marquardstr. 35, 36039 Fulda
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:
Prof. Dr. W. Heinzel, Hochschule Fulda, FB AI, Marquardstr. 35, 36039 Fulda
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.
Prof. Dr. W. Heinzel, Hochschule Fulda, FB AI, Marquardstr. 35, 36039 Fulda
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);
Prof. Dr. W. Heinzel, Hochschule Fulda, FB AI, Marquardstr. 35, 36039 Fulda
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
Prof. Dr. W. Heinzel, Hochschule Fulda, FB AI, Marquardstr. 35, 36039 Fulda
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.
Prof. Dr. W. Heinzel, Hochschule Fulda, FB AI, Marquardstr. 35, 36039 Fulda
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.
Prof. Dr. W. Heinzel, Hochschule Fulda, FB AI, Marquardstr. 35, 36039 Fulda
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