Grundlagen der Java 3D- Programmierung

Transkript

1 Grundlagen der Java 3D- Programmierung und deren exemplarische Umsetzung Verfasser: MATSE-Auszubildender am Institut für Leichtbau der RWTH Aachen, angehender Bachelor of Science Die vorliegende Arbeit wurde im Rahmen der Seminar-Veranstaltung des Rechen- und Kommunikationszentrums der RWTH Aachen erstellt und soll einen Einstieg in die dreidimensionale Programmierung mit Java bieten.

2 Inhaltsverzeichnis 1 Motivation 2 Allgemeine Informationen zu Java 3D 2.1 Was ist Java 3D? 2.2 Geschichtliche Entwicklung 2.3 Installation 3 Der Szenengraph die virtuelle Welt 3.1 Objekte im Szenengraph-Modell 3.2 Java 3D-Klassenhierarchie 3.3 Das SimpleUniverse 3.4 Programmstruktur einer Java 3D-Anwendung 4 Geometrische Transformationen 4.1 Das Koordinatensystem in Java 3D 4.2 Theoretische Grundlagen 4.3 Translation, Rotation und Skalierung in Java 3D 5 Geometrien in Java 3D 5.1 Modellierung mit Primitiven 5.2 Komplexere Objekte 6 Objekteigenschaften 6.1 Beleuchtung in Java 3D 6.2 Die Appearance 7 Bewegungen in Java 3D 7.1 Animation 7.2 Interaktion Literaturverzeichnis 2

3 1 Motivation Am Institut für Leichtbau (ilb) der RWTH Aachen existiert ein in der Programmiersprache Fortran77 geschriebenes Berechnungsprogramm namens ASTRA. Mit diesem lassen sich Rotationsschalen beliebiger Meridiankurve aus ingenieurtechnischer Sicht untersuchen. Dabei wird die Untersuchung mithilfe der Finite-Elemente-Methode (FEM) durchgeführt, wobei es sich im Wesentlichen um ein Verfahren zur Lösung partieller Differentialgleichungen handelt. Hierbei wird das zu untersuchende Gebiet in Elemente endlicher Größe zerlegt, auf die schließlich die Berechnungen angewandt werden. Als Ergebnis liefert ASTRA u.a. dreidimensionale Raumkoordinaten einer Geometrie und Verschiebungswerte dieser Raumkoordinaten. Der ehemalige Auszubildende Michael Schmidt begann im Rahmen seiner Bachelorarbeit damit, ein Programm zu entwickeln, welches die Ergebnisdaten von ASTRA grafisch darstellt¹. Diese Aufgabe wurde bisher durch ein kommerzielles Programm übernommen. Aufgrund der Komplexität dieser Thematik besteht jedoch die Möglichkeit, die Weiterentwicklung des Programms zum Thema einer weiteren Bachelorarbeit zu machen. 2 Allgemeine Informationen zu Java 3D 2.1 Was ist Java 3D? Die Java 3D-API² stellt eine plattformunabhängige High-Level 3D API mit einem hohen Grad an Interaktivität ³, also eine abstrakte, völlig plattform- und hardwareunabhängige Programmierschnittstelle dar. Dementsprechend beinhaltet sie eine Klassenbibliothek von Java-Klassen 4 zur Erzeugung, Manipulation und Darstellung dreidimensionaler Grafiken innerhalb von Java-Anwendungsprogrammen und -Applets. Mit einem Java 3D-Programm können also dreidimensionale Objekte modelliert, gerendert sowie das Verhalten und die Ansicht gesteuert werden. Rendern bedeutet hier das Erzeugen eines Bildes aus einer Szene, wobei eine Szene ein virtuelles räumliches Modell, das dreidimensionale Objekte und deren Materialeigenschaften, Lichtquellen sowie die Position und Blickrichtung eines Betrachters definiert. Der Aufbau von Java 3D unterscheidet sich deutlich von anderen gängigen, eng mit der 3D-Hardware verbunden Grafik-APIs, wie das plattformunabhängige OpenGL oder Microsofts Direct3D, welches Bestandteil von DirectX ist. Im Gegensatz zu diesen verwendet Java 3D zur Verwaltung der Grafikobjekte einen sogenannten Szenengraphen, welcher, hierarchisch aufgebaut, alle Informationen über die darzustellenden Objekte und ihre Bearbeitung enthält. Die erwähnten beiden Low-Level-Rendering-APIs werden anschließend zur Darstellung der dreidimensionalen Objekte verwendet, wobei Java 3D die von diesen Schnittstellen verwendete 3D-Beschleunigungshardware für das Rendern der Szenen ausnutzt. ¹ für nähere Erläuterungen siehe [9] ² application programming interface, Schnittstelle zur Anwendungsprogrammierung ³ aus The Java 3D API Technical Whitepaper 4 eine Java-Klasse beinhaltet Datenvariablen und Methoden, wie diese zu bearbeiten sind 3

4 2.2 Geschichtliche Entwicklung Abb.1: Kontext um Java 3D. Aus: [6] Java 3D wurde seit 1997 von Sun Microsystems entwickelt. Die Version 1.0 erschien im Dezember 1998, die Version 1.4 ist seit März 2006 verfügbar. Als wichtiges Leistungsmerkmal ist hier die Möglichkeit der Shader-Programmierung, also die vorhandene Implementierung von Softwaremodulen für bestimmte, insbesondere visuelle Renderingeffekte für die entsprechende Grafikhardware, hervorzuheben. Aktuell ist die Version 1.5, die unter anderem die Rendering-Pipeline Jogl¹ auf allen Plattformen einführt. Nachdem Sun die Weiterentwicklung zwischenzeitlich eingestellt hatte, ist die Bibliothek seit Sommer 2004 als Open Source freigegeben. 2.3 Installation Java 3D kann unter der folgenden Adresse der Projekthomepage als Installer oder Zipbinary bezogen werden: Es sind derzeit OpenGL-Fassungen für Windows-Systeme und diverse UNIX-Plattformen erhältlich sowie eine Version für Direct3D auf Windows 2000 und Windows XP. Für Mac OS X gibt es eine Version für das JDK² 1.4 (bis 10.3), das JDK 1.5 für Mac OS X (10.4) enthält bereits Java 3D in Version 1.3. Da Java 3D in das lokale JRE integriert wird, wird auch das aktuelle JDK/JRE benötigt, um es installieren zu können: Dabei sind die folgende Pakete essentiell: j3d-core (Java 3D-Kernbibliothek) vecmath (Vektormathematik-Bibliothek) j3d-core-utils (verschiedene Java 3D-Utilities) Bei der Verwendung von der Entwicklungsumgebung Eclipse muss bei der Konfiguration zusätzlich beachtet werden, dass beim Ausführen nicht die vorhandene Java Virtual Machine (Java VM) benutzt wird, sondern die gerade zuvor mit dem JDK installiert wurde. ¹ Java OpenGL. Eine externe OpenGL-Programmbibliothek für die Programmiersprache Java, mit dessen Hilfe ein Programmierer direkt auf OpenGL-Funktionen zugreifen kann. ² Java Development Kit. Eine Sammlung von Werkzeugen und Anwendungen, um Software zu erstellen (Software Development Kit). Beinhaltet u.a. die Laufzeitumgebung Java Runtime Environment (JRE). 4

5 3 Der Szenengraph die virtuelle Welt Wie bereits erwähnt, kapselt Java 3D die Funktionalität der zugrunde liegenden OpenGLoder DirectX-Schnittstelle in ein leichter verständliches objektorientiertes Konzept auf Basis eines Szenengraphen. Hierbei wird der logische Aufbau der darzustellenden Objekte¹ auf eine gleichartig aufgebaute, baumähnliche Struktur abgebildet, die im Wesentlichen aus Definitionen von Transformationen und Geometriedaten besteht. Die so strukturierte Sicht der Szene erlaubt eine komfortable Handhabung der Objekte. Dazu implementiert die Bibliothek Klassen zur Repräsentation einer Szene und nutzt für deren Darstellung ausschließlich die erwähnten vorimplementierten und an das jeweilige Betriebssystem angepassten Funktionsbibliotheken. Dadurch ist die erreichbare Renderinggeschwindigkeit ähnlich hoch wie bei direkter Programmierung mit C und OpenGL oder Direct3D. Ein direkter Zugriff auf OpenGL- oder Direct3D-Funktionen ist dabei von Java 3D nicht vorgesehen. Der Szenengraph von Java 3D besteht aus zwei Teilen: Zum einen dem Viewing -Zweig, der alle für die Definition der Darstellung und Projektion erforderlichen Parameter enthält, und zum anderen dem Content -Zweig, der die darzustellende Szene definiert (Geometrie, Transformationen, etc.). Der Szenengraph entspricht auch einer Datenstruktur mit Knoten und Kanten. Ein Knoten gilt repräsentativ für eine der beiden Subklassen des SceneGraphObject, der Superklasse aller Szenengraph-Objekte. Eine Kante steht für die Beziehung zwischen den Knoten. Die beiden angesprochenen möglichen Subklassen, also Node und NodeComponent, sind wiederum Superklassen aller Nodes (z.b. TransformGroup und Shape3D) bzw. aller NodeComponents (z.b. Geometry und Appearance). Die Kante kann auf zwei Arten eine Beziehung zwischen zwei Knoten herstellen: Eltern-Kind-Beziehung (parent-child-link) Referenz-Beziehung (reference) Knotenobjekte des Graphen befinden sich immer in einem von drei Zuständen: Nach der Erzeugung, aber vor dem Einfügen in den Graphen ist ein Knoten detached alle seine Attribute können ausgelesen und verändert werden. Wird der Knoten in den Szenengraphen eingefügt, so ist er live nur Operationen, die vorher explizit freigegeben wurden (Capabilities), können durchgeführt werden. Nach der Optimierung eines zu einem Knoten gehörigen Teilgraphen (compile) ist der Knoten im Zustand compiled. Die im Knoten enthaltene Information wurde für das Rendering optimiert Änderungsmöglichkeiten, z.b. Geometrieinformation, sind dadurch aber eingeschränkt. ¹ im Nachfolgenden kann es zu einer gewissen Mehrdeutigkeit des Begriffes des Objektes kommen: Zum einen der bekannte Begriff des Java-Objektes als Instanz einer Klasse, zum anderen in Form einer dreidimensionalen Geometrie. Die Bedeutung des Begriffes ist dem jeweiligen Kontext zu entnehmen. 5

6 3.1 Objekte im Szenengraph-Modell Klassenübersicht des Szenengraphen (siehe Abb.2): VirtualUniverse : Wurzelknoten des Szenengraphen; Locale : bildet für den darunter strukturierten Teilbaum immer einen Ursprung (Wurzelknoten); gibt räumlich zusammengehörige Bereiche des Universums an; wenn Geometrie mit ausreichender Genauigkeit über mehrere Größenordnungen definiert werden soll: mehrere Locales ; enthält über BranchGroups mehrere Subgraphen Group : Vorfahre aller Zwischenknoten im Graphen; dient als Basisklasse für weitere Subklassen BranchGroup : Subgraph; bestehend aus inneren Group -Knoten und Leaf -Knoten TransformGroup : enthält Transformation, die auf alle seine Nachfolger angewendet wird Shape3D : Blattknoten; definiert ein Geometrieobjekt in der Szene NodeComponent : legt mit Subklassen Appearance und Geometry Attribute zur Darstellung des entsprechenden Objektes fest View : koordinierende Aufgabe PhysicalBody : definiert relevante physikalische Eigenschaften des realen Betrachters PhysicalEnvironment : definiert die vorhandenen Sensoren, d.h. die 3D-Eingabegeräte Canvas3D : dient zur Ausgabe auf einem Anzeigegerät; physikalische Größen wie etwa Breite und Höhe werden in Screen3D abgelegt Abb.2: Szenengraph in Java3D mit dem Content-Zweig (links) und dem Viewing-Zweig (rechts). Aus: [5] 6

7 3.2 Die Java 3D-Klassenhierarchie Nachfolgend ein Auszug der ersten 3 Hierarchie-Ebenen aus dem Kernpaket (j3d-core) von Java 3D: Abb.3: Auszug der Klassen des Java 3D API Packages javax.media.j3d.*. Aus: [4] 3.3 Das SimpleUniverse Meist liegt der Fall vor, dass sich der Ansichtsteilbaum von unterschiedlichen Programmen nicht erheblich unterscheidet. Deshalb implementierten die Entwickler von Java 3D eine Möglichkeit, das Erzeugen einer dreidimensionalen Szene zu vereinfachen und die Fehlermöglichkeit zu minimieren. Der Konstruktor dieser Hilfsklasse erzeugt einen Szenengraphen, der die notwendigen Objekte Locale und VirtualUniverse sowie den gesamten Ansichtsteilbaumgraphen bereits bereitstellt. Es wird jedoch fortan nur mit einem einzigen View gearbeitet. Des weiteren bedient sich die Klasse SimpleUniverse zwei Utility-Klassen (ViewingPlatform, Viewer) und verzichtet auf den Zugriff der Java 3D Core-Klassen. Über eben diese beiden Klassen kann man auch noch ggf. im Nachhinein die aktuelle View- Position verändern. Dazu ist noch anzumerken, dass Java 3D nicht wie viele andere APIs die Szene bei einer Betrachterbewegung verändert, sondern den View. Dadurch verändert sich der Inhalts- Teilbaum nicht, was eine saubere Trennung zwischen physikalischer und virtueller Welt darstellt. 7

8 Abb.4: Szenengraph mit eingegrenztem Bereich, der von der Klasse SimpleUniverse kreiert wird. Aus: [4] 3.4 Programmstruktur einer Java 3D-Anwendung Folgender Ablauf bezieht sich auf die Verwendung der SimpleUniverse-Klasse. 1. Import der benötigten Java-, Java 3D und Java 3D-Utility-Packages, beispielsweise: import java.awt.*; import javax.media.j3d.*; import javax.vecmath.*; import com.sun.j3d.utils.*; 2. Erstellung eines AWT- oder SWING-basierten Rahmenprogramms 3. Erzeugung eines Canvas3D-Objektes 4. Erzeugung eines SimpleUniverse-Objektes und Übergabe des Canvas3D 5. Justierung der ViewPlatform des SimpleUniverse 5. Konstruktion des Inhaltsteilbaums 6. Kompilieren des Inhaltsteilbaums 7. Hinzufügen des Inhaltsteilbaums zum SimpleUniverse 8

9 4 Geometrische Transformationen 4.1 Das Koordinatensystem in Java 3D Die Orientierung der Raumachsen in Java 3D bildet ein rechtshändiges Koordinatensystem. In der Nomenklatur von Java 3D wird der so aufgespannte Raum als Virtuelles Universum bezeichnet. Die Positionierung von Objekten geschieht dabei mittels dreidimensionaler Koordinaten. In einem rechtshändigen Koordinatensystem wird die x-achse durch eine 90 -Drehung, d.h. gegen den Uhrzeigersinn, um die z-achse in die y-achse überführt, die y-achse durch eine 90 -Drehung um die x-achse in die z-achse und die z-achse durch eine 90 -Drehung um die y-achse in die x-achse. Als Hilfestellung dieses Sachverhaltes dient auch die in vielen Bereichen bekannte Rechte-Hand-Regel. Diese besagt, wenn der Daumen der rechten Hand in die positive Richtung einer orientierten Achse zeigt, dann zeigen die Finger die positive Drehrichtung. Im Unterschied zu einem linkshändigen System ist bei einem rechtshändigen die positive z-achse dem Betrachter entgegen gerichtet, er schaut also in negative z-richtung. Des weiteren besitzt das in Java 3D verwendete Koordinatensysteme die Eigenschaft, dass die Raumpunkte der Polygone, die ein beliebig komplexes Objekt bilden, entgegen dem Uhrzeigersinn angegeben sind. Polygone, deren Raumpunkte im Uhrzeigersinn angegeben sind, werden ignoriert. Sofern nicht spezielle Transformationen angewandt wurden oder der Standpunkt des Betrachters geändert wurde, zeigt die x-achse im Darstellungsfenster nach rechts, die y- Achse nach oben und die z-achse nach vorn. Des weiteren gibt die z-komponente die Entfernung zum Betrachter an und die Achsen-Einteilung erfolgt in Metern. Abb.5: Das rechtshändige Koordinatensystem in Java 3D. Aus: [2] Lediglich dieses Koordinatensystem ist vorgesehen. Es gibt daher keine Möglichkeit, den Achsen eine andere Orientierung zuzuordnen. Die Locales-Objekte ermöglichen es durch die Implementierung der Koordinaten als 256- Bit-Festkommazahl auch, ein sehr präzises Koordinatensystem zu verwenden. In diesem lassen sich beispielsweise Berechnungen von Objekten in atomarer Ebene bis zum Makrokosmos durchführen. Durch u.a. diese Fähigkeit ist die API auch für wissenschaftliche Anwendungen interessant. 9

10 4.2 Theoretische Grundlagen Die theoretische Grundlage für die hier behandelten Transformationen Translation, Skalierung und Rotation bilden mathematische Matrizenmultiplikationen. Bevor die entsprechenden Matrizen jedoch vorgestellt werden können, muss der Begriff der homogenen Koordinaten eingeführt werden. Homogene Koordinaten erlauben die Darstellung von affinen Transformationen durch eine Multiplikation der Koordinaten mit Matrizen, wobei sie für die Darstellung der Punkte eine zusätzliche Dimension verwenden. Eine affine Transformation liegt dann vor, wenn beide beteiligten Koordinatensysteme linear, d.h. im Prinzip gegeben durch einen Koordinatenursprung und gleichmäßig unterteilte Koordinatenachsen, sind. Des weiteren dienen diese Koordinaten zur Umrechnung von Koordinatensystemen. Im Grunde genommen kann eine Transformation auch als Wechsel des Koordinatensystems verstanden werden. Um hierbei Rundungsfehler zu vermeiden und Berechnungsaufwand zu reduzieren, ist es vorteilhaft, mehrere aufeinander folgende Matrixtransformationen nur zu einer einzigen Transformationsmatrix zusammenzufassen. Der in homogenen Koordinaten vorliegende Punkt x', y', z ', w,w 0 wird durch den Punkt x ' w, y' w, z ' w aus dem Raum der dreidimensionalen reellen Zahlen repräsentiert. Auf diese Weise lassen sich also n-dimensionale Transformationen als Matrizen der Größe (n+1) * (n+1) darstellen. Die hier behandelten Transformationen im dreidimensionalen Raum können also als 4x4-Matrizen beschrieben werden. Eine Translation stellt eine Verschiebung der Punkte eines Objektes dar. Die Translation um einen Vektor a,b, c T, also die Verschiebung der Punkte um a-einheiten in x- Richtung, um b-einheiten in y-richtung und um c-einheiten in z-richtung, lässt sich in homogenen Koordinaten als Matrixmultiplikation der Form x' = a y ' b y y b z ' c z z c x 1 = x a a b mit der Transformationsmatrix T a,b,c = 1 1 darstellen c Bei der Skalierung eines Objektes, d.h die Dehnung bzw. Stauchung, um die Faktoren d, e, und f wird die x-koordinate um den Faktor d, die y-koordinate um den Faktor e und die z-koordinate um den Faktor f vergrößert bzw. verkleinert. 10

11 Dabei ist die Matrixmultiplikation x' = d y ' 0 e 0 0 y z ' 0 0 f 0 z x e y f z 1 = d x 1 mit der Skalierungsmatrix S d, e, f = d e f gegeben. Bei der Rotation, also der Drehung um eine Achse, muss zunächst festgelegt werden, um welche Achse rotiert werden soll. Die drei elementaren Rotationen im Dreidimensionalen sind die Rotationen um die Koordinatenachsen. Die Rotation um die z-achse um den Winkel φ lässt sich folgendermaßen in homogenen Koordinaten beschreiben: x' = cosφ sinφ 0 0 y ' sinφ cosφ 0 0 y z ' z x 1 mit der Rotationsmatrix R φ = cosφ sinφ 0 0 sinφ cosφ Bei einer Rotation um die z-achse ändert sich dabei die z-koordinate nicht. Analog gilt für die x- bzw. y-achse: cosφ sinφ 0 R φ = 1 1 bzw. 0 sinφ cosφ R φ = cosφ 0 sinφ sinφ 0 cosφ Durch eine geeignete Hintereinanderausführung dieser drei Rotationen um die Koordinatenachsen in Kombination mit geeigneten Translationen kann eine Rotation um eine beliebige Achse und um einen beliebigen Winkel φ beschrieben werden. Dabei wird grundsätzlich nach dem folgenden Schema vorgegangen: Verschiebung der Rotationsachse in den Koordinatenursprung Rotation um die z-achse, so dass die Rotationsachse in der y/z -Ebene liegt Rotation um die x-achse, die die Rotationsachse auf die z-achse abbildet Rotation um den Winkel φ um die z-achse Umkehrung der drei vorhergehenden Transformationen 11

12 4.3 Translation, Rotation und Skalierung in Java 3D Standardmäßig werden in Java 3D alle Objekte absolut bezüglich der Weltkoordinaten platziert. Diese oftmals nicht gewünschte Vorgehensweise lässt sich allerdings durch die Verwendung der bereits angesprochenen Transformationsgruppen, den TransformGroup- Objekten, umgehen. Ein TransformGroup-Objekt erlaubt die Verwendung eines neuen Koordinatensystems, das relativ zum Koordinatensystem des Elternknotens angeordnet ist. Verändert bzw. transformiert man nun die TransformGroup, bewegen sich gleichzeitig auch alle Objekte in dieser Gruppe. Bei Verwendung dieses Eltern-Kind-Prinzips über mehrere Ebenen akkumulieren sich die Transformationen der einzelnen Ebenen, wobei tiefer im Szenengraph gelegene Transformationen nach dem Abarbeitungsprinzip des Szenengraphen zuerst ausgeführt werden. Jedoch lassen sich durch die Verwendung von TransformGroup-Objekten noch keine eigentlichen Transformationen nach obigen Schema durchführen. Dazu werden die Transform3D-Objekte benötigt, welche also dreidimensionale Transformationen als Matrix in homogenen Koordinaten speichern. Sie dienen dementsprechend zur Beschreibung der Transformationen einer TransformGroup und müssen dieser anschließend zugewiesen werden. Mittels des folgenden Konstruktor-Aufrufs erzeugt man in Java 3D eine 4*4-Matrix, welche der Einheitsmatrix entspricht und die entsprechende Transformation aufnimmt: Transform3Dtf =new Transform3D ; Es gibt die Möglichkeit, durch Angabe eines dreidimensionalen Verschiebungsvektors oder einer 4*4-Matrix, welche die Verschiebung enthält, eine Translation darzustellen. Im Folgenden nur der einfachere Fall mittels des Verschiebungsvektors. Eine Translation um einen float-vektor x, y, z T tf.settranslation new Vector3f x, y,z ; wird definiert durch: Für eine Skalierung existiert die Möglichkeit, alle Achsen des Koordinatensystems mit dem gleichen Faktor zu skalieren oder für jede Achse den gewünschten Skalierungsfaktor separat anzugeben. Eine gleichmäßige Skalierung um den Faktor factor ist definiert durch: tf.setscale factor ; Entgegen dem eine separate Skalierung um den float-vektor x, y, z T tf.setscale new Vector3f x, y, z ; in jede Richtung: 12

13 Eine Rotation bietet die größte Vielfalt an Methoden und möglichen Vorgehensweisen, auch deshalb, da es jeweils unterschiedliche Transformationsmatrizen für die Drehung um die x-, y- und z-achse gibt. Bei der Rotation eines Objekts um die x-achse bleiben die x- Koordinaten der Punkte konstant und nur die y- und z-koordinaten verändern sich. Des weiteren besteht die Möglichkeit der Drehung um eine beliebige Achse mit einem beliebigen Winkel. Eine Rotation um den Winkel φ um bspw. die x-achse ist folgendermaßen definiert: tf.rotx φ ; Dabei muss der Winkel φ im Bogenmaß angegeben werden. Analog wird mit roty bzw. rotz eine Rotation um die y- bzw. z-achse spezifiziert. Eine Rotation um den Winkel φ um die Achse in Richtung des float-vektors x, y, z T wie folgt festgelegt: tf.set new AxisAngle4d x, y, z,φ ; wird Des weiteren sind mittels tf.set mat ; beliebig definierte Transformationen möglich. Dabei ist mat ein eindimensionales double-array mit 16 Werten, die die Matrixeinträge definieren. Auch sind mittels tf.mul tf1,tf2 ; bzw. tf1.mul tf2 ; Hintereinaderschaltungen von Transformationen im Sinne der Matrixmultiplikation möglich. Hier werden die Hintereinaderschaltungen der Transformationen tf1 und tf2 in der Transformation tf gespeichert bzw. in der Transformation tf1. Hierbei sollte jedoch aufgrund der nicht erfüllten Kommutativität der Matrixmultiplikation auf die Reihenfolge geachtet werden. Abschließend darf natürlich nicht vergessen werden, mittels der bereits erwähnten TransformGroup die vorgenommene Transformation zu referenzieren. Entweder gleich bei der Instantiierung TransformGrouptg=new TransformGroup Transform3D tf ; oder nachträglich mittels Methodenaufruf TransformGrouptg=new TransformGroup ; tg.settransform tf ; 13

14 5 Geometrien in Java 3D Die eigentlichen Geometrien, also dreidimensionale Objekte, die eine Sammlung von zusammen gerenderten Koordinaten enthalten, werden in Java 3D in den Blattknoten spezifiziert. Dies geschieht in Objekten der Klasse Shape3D, einer Subklasse von Leaf. Die eigentlichen Geometrie-Daten werden auf eine Geometry-Komponente referenziert, die Daten für die visuelle Erscheinung des Objektes auf eine Appearance-Komponente. Beide sind jeweils Unterklassen der abstrakten Klasse NodeComponent, welche die allgemeine Oberklasse für Blattattribute darstellt. Für Geometry steht eine Vielzahl an Klassen zur Verfügung, welche sich letztlich fast alle auf die Grund-Primitiven Punkt, Linie, Dreieck und Viereck zurückführen lassen. 5.1 Modellierung mit Primitiven Java 3D stellt im Utility-Paket bereits Konstrukte mit untergeordneten Shape3D-Objekten in Form der Stammfunktionen-Klasse (Primitive-Klasse) zur Verfügung. Box, Cone, Cylinder und Sphere sind praktische Unterklassen dieser abstrakten Klasse, mit denen sich einfache geometrische Objekte erstellen lassen. Box: kreiert einen Quader Kantenlänge 2 Meter Mittelpunkt im Koordinatenursprung Konstruktoren: Box box=new Box ; Default-Konstruktor Box box=new Box x, y, z, myapp ; Cone: kreiert einen Kegel Radius: 1 Meter, Höhe: 2 Meter Mittelpunkt des Grundkreises im Koordinatenursprung Konstruktoren: Cone cone=new Cone ; Default-Konstruktor Conecone=new Cone r,h, myapp ; Cylinder: kreiert einen Zylinder Radius: 1 Meter, Höhe: 2 Meter Zentrum der zentralen Achsen im Koordinatenursprung Konstruktoren: Cylinder cylinder=new Cylinder ; Default-Konstruktor Cylinder cylinder=new Cylinder r, h, myapp ; 14

15 Sphere: kreiert eine Kugel Radius: 1 Meter Mittelpunkt ist Koordinatenursprung Konstruktoren: Sphere sphere=new Sphere ; Default-Konstruktor Sphere sphere=new Sphere r,myapp ; Erfolgt keine Referenz zu einem Appearance-Objekt, in den obigen Fällen durch myapp geschehen, erscheint das dargestellte Objekt in der Farbe Weiß. Abb.6: Auszug der Primitiven aus dem Utility-Paket von Java 3D. Aus: [4] Die erwähnten geometrischen Objekte werden in Java 3D durch Dreiecke angenähert. Dieser Sachverhalt wird auch als Tesselierung bezeichnet, was die Zerlegung von komplexen Polygonen in so genannte primitive Flächen, beispielsweise Drei- und Vierecke, aufgrund der einfacheren Handhabung solcher Flächen bedeutet. Der Vorteil der Approximation durch Dreiecke besteht darin, dass effiziente Algorithmen für zu tätigende Berechnungen bereits auf der Grafikkarte implementiert, sie hierfür also optimiert, sind. Des weiteren kann bei den obigen Geometrien, mit Ausnahme des Quaders, die Anzahl der Dreiecke angegeben werden, die die Oberfläche annähern sollen. Je größer die Anzahl dieser Dreiecke ist, desto höher ist auch der Detaillierungsgrad der approximierten Oberfläche, wobei sich aber auch der Rechenaufwand enorm erhöht. Erwähnenswert ist auch noch die Klasse ColorCube, eine spezielle farbige Box. Diese ist aber nicht wie zu erwarten ein Primitive, sondern bereits eine Subklasse von Shape3D. Im Gegensatz zu obigen erwähnten lässt sich bei diesem Gebilde auch nur noch die Größe des Objektes ändern, nicht aber mehr das Erscheinungsbild. 15

16 5.2 Komplexere Objekte Nicht immer besteht die Möglichkeit, in der Realität vorkommende Objekte durch die im letztem Kapitel Erläuterten darzustellen, da hierzu komplexere Formen benötigt werden. Zum einen kann man diese durch professionelle 3D-Modellierungssoftware erstellen, zum anderen bringt Java 3D die entsprechenden Werkzeuge, um z.b. aus externen Daten Geometrien zu erzeugen, aber auch bereits mit. Für die Erstellung benötigt man zunächst sogenannte Vertices, also 3D-Koordinaten, die zusammen mit den Polygonen die Form eines Objektes festlegen. Diese Vertices, auch als Eck- bzw. Scheitelpunkt bezeichnet, können aber auch noch andere Informationen, wie z.b. einen Farbwert, Transparenz mittels eines Alpha-Wertes, einen Normalenvektor oder eine zusätzliche Positionsangabe für Texturkoordinaten, enthalten. Normalenvektoren finden für Beleuchtungseffekte Verwendung, Texturkoordinaten für die Darstellung von Texturen auf Oberflächen mittels Texturmapping. Bei Verwendung der Primitives werden die Scheitelpunkte und die Texturkoordinaten automatisch erzeugt. Die erwähnten Polygone sind in der Regel Dreiecke oder Vierecke, aber auch Vielecke mit einer fast beliebig großen Anzahl Ecken sind möglich. Sie haben jedoch alle gemeinsam, dass sie durch die Angabe der Vertices, aus denen sie sich zusammensetzen, eindeutig beschrieben werden. Im folgenden Beispiel werden Dreiecke dazu benutzt, die Oberflächen zu beschreiben. Dazu müssen zunächst die Eckpunkte der Dreiecke abgelegt werden: Point3f [ ] points={new Point3f x0, y0, z0,new Point3f x1, y1,z1...}; Die Koordinaten der Punkte werden hierbei als float-werte angegeben. Anschließend muss festgelegt werden, welche drei Punkte jeweils eine Dreiecksfläche bilden. Die Dreieckspunkte werden dabei als Indizes der Punkte im obigen Point3f-Array spezifiziert. Das könnte bspw. durch folgendes Array realisiert werden: int triangles[ ]={0,3,1,0,2,3,0,1,2,1,3,2}; Hier würden die Punkte der Indizes 0,3,1 und 0,2,3 sowie 0,1,2 und 1,3,2 jeweils ein Dreieck bilden. Es ist jedoch unbedingt darauf zu achten, die Punkte für jedes Dreieck in der richtigen Reihenfolge anzugeben. Wenn man von außen auf die Fläche schaut, müssen die Eckpunkte entgegen dem Uhrzeigersinn durchlaufen werden. Danach muss man angeben, was die einzelnen Vertices für Polygone bilden sollen. Die entsprechenden, bereits erstellten Daten müssen ebenfalls übergeben werden. In diesem Fall bilden 3 Vertices ein unabhängiges Dreieck: GeometryInfo gi=new GeometryInfo GeometryInfo.TRIANGLE _ ARRAY ; gi.setcoordinates points ; gi.setcoordinateindices triangles ; Dann erzeugt man Normalenvektoren für das zu generierende Objekt, welche wie bereits angesprochen für Lichteffekte zuständig sind: 16

17 NormalGenerator ng =new NormalGenerator ; ng.generatenormals gi ; Anschließend wird aus den bereits vorhandene Daten ein GeometryArray-Objekt erzeugt: GeometryArray ga= gi.getgeometryarray ; GeometryArray ist dabei eine von Geometrie erbende Klasse, die vier Basistypen in Form von Punkt, Linie, Drei- und Viereck zur Verfügung stellt. Sie ist jedoch nur eine Basisklasse, konkrete Ausführungen liegen in PointArray, LineArray, TriangleArray und QuadArray vor. Der letzte Schritt besteht in der Erzeugung eines Objektes, das anstelle der bisher verwendeten Primitiven tritt und alle nötigen Informationen aufnehmen kann: Shape3D myshape=new Shape3D ga, myapp ; Dieses Shape3D-Objekt kann in Szenen genauso verwendet werden wie die elementaren geometrischen Objekte, wobei myapp wieder ein Objekt vom Typ Appearance ist. Die bereits eingeführte Klasse Primitive leitet sich nicht von der Klasse Shape3D ab. Intern werden bei den einfachen geometrischen Objekten natürlich Shape3D-Objekte verwendet, da sich diese Primitiven letztendlich auch nur aus dynamisch erzeugten Geometriedaten zusammensetzen. Jedoch sind diese so gekapselt, dass es nicht möglich ist, mittels explizitem Konvertieren ( casten ) ein entsprechendes Objekt in vergleichbarer Weise zu verwenden wie ein Shape3D-Objekt. Die Darstellung von Objekten durch Polygonflächen ist u.a. vom Programmieraufwand her die aufwendigste der hier beschriebenen Vorgehensweisen. Sie bietet jedoch auch die größten Freiheiten, da auf diese Weise jedes komplexe, aus Flächen aufgebaute Objekt beschrieben werden kann. Weiter bietet Java 3D die Möglichkeit, verschiedene Dateiformate zur Beschreibung geometrischer Objekte in der Computergrafik einzubinden. Auf diese Weise lassen sich bereits vorgefertigte Objekte oder mit geeigneten Modellierungswerkzeugen selbst erstellte Objekte in Szenen einbinden. Wenn die Geometriedaten in einem von Java 3D unterstütztem Dateiformat vorliegen, können diese mittels der Klasse Loader in das Programm eingebunden werden. Beispielsweise ist das Wavefront Object-Format (.obj) ein unterstütztes Dateiformat, welches ähnliche Informationen wie die bereits angesprochenen GeometryArrays beinhaltet. 17

18 6 Objekteigenschaften 6.1 Beleuchtung in Java 3D Zu der Darstellung einer dreidimensionalen Szene gehören neben den Objekten und dem Betrachter auch Informationen über die Beleuchtung, die auch von unterschiedlichen Lichtquellen stammen kann. Mit diesem Beleuchtungsmodell (Lightning-Model) versucht Java 3D, die Gegebenheiten der realen Welt nachzubilden. Um dies zu erreichen, werden für jeden Vertex¹ eines Objekts drei Vektoren für die Berechnung des schlussendlich sichtbaren Lichtes berücksichtigt. Das sind der bereits angesprochene Normalenvektor, der Strahl von dem Objekt zum Auge des Betrachters und natürlich der Strahl von der Quelle des Lichtes zum Objekt. Zu der Spezifikation einer Lichtquelle benötigt man allgemein neben der Lichtart noch die Farbe sowie speziell in Java 3D einen Wirkungsbereich des Lichtes. Die Farbe des Lichtes legt man in Java 3D mit folgendem Konstrukt fest: Color3f lightcolour=new Color3f r, g,b ;, wobei r, g,b für den RGB-Anteil der darzustellenden Farbe in float-werten zwischen 0 und 1 steht. Der Wirkungsbereich, also die Angabe, ob eine bestimmte Aktion überhaupt zur Anwendung kommt, wird mit Hilfe eines Bounding-Objektes festgelegt, z.b. mittels einer Instanz der Klasse BoundingBox oder BoundingSphere: BoundingSphere bs=new BoundingSphere new Point3d x, y, z,r ; Dadurch wird ein kugelförmiger Bereich mit dem Radius r um den Punkt x, y, z definiert, in dem überhaupt Berechnungen durchgeführt werden. Dieses Konzept wird an mehreren Stellen in Java 3D verwendet, da dadurch außerhalb des angegebenen Wirkungsbereiches Rechenzeit eingespart werden kann. Zur Modellierung von Lichtquellen existieren in Java 3D vier Arten, welche alle Subklassen der abstrakten Light-Klasse sind. Die einfachste Form dieses Lichtes ist das ambiente Licht bzw. Streulicht. Es geht nicht von einer speziellen Quelle aus, sondern repräsentiert das Licht, das durch mehrfache Reflexionen an verschiedenen Oberflächen nahezu überall vorhanden ist. Durch folgende Schritte wird in Java 3D ambientes Licht erzeugt: AmbientLight light=new AmbientLight lightcolour ; light.setinfluencingbounds bs ; Im Gegensatz zu ambientem Licht hat direktionales Licht noch zusätzlich eine Richtung, aus der es kommt. Mit seinen parallel verlaufenden Lichtstrahlen simuliert es unendlich weit entfernte Lichtquellen. Mit dem nachfolgenden Befehl wird diese Art von Licht erzeugt: ¹ Eck- bzw. Scheitelpunkt eines Primitivs. Mehrzahl: Vertices, nähere Erläuterungen auf Seite 16 18

19 Vector3f direction=new Vector3f x, y, z ; DirectionalLight light=new DirectionalLight lightcolour, direction ; light.setinfluencingbounds bs ; Neben diesen beiden wichtigsten stehen noch punktförmige Lichtquellen und Spotlights zur Verfügung. Bei punktförmigen Lichtquellen, repräsentiert durch die Klasse PointLight, breitet sich das Licht von der entsprechenden Position in alle Richtungen aus, wobei die Intensität mit der Entfernung von der Lichtquelle stetig abnimmt. Im Gegensatz dazu strahlt das Licht von Spotlights, repräsentiert durch die gleichnamige Klasse, nur in eine Richtung ab und breitet sich dann kegelförmig aus. Der eben beschriebene Effekt der Dämpfung findet aber ebenso statt. Die eigentlichen Lichtquellen sind grundsätzlich unsichtbar, sie senden ihr Licht lediglich an Objekte in der Szene. Abschließend muss das ausgewählte Licht noch in den Szenengraphen eingebunden werden, z.b. mittels einer eigenen BranchGroup, um die Unabhängigkeit von einem geometrischen Objekt und Übersichtlichkeit sicherzustellen: BranchGroup bglight=new BranchGroup ; bglight.add light ; 6.2 Die Appearance Wie bereits erwähnt wird bei Shape3D-Objekten zwischen den eigentlichen Geometriedaten und dem Aussehen unterschieden. Obwohl sich einige Informationen in Scheitelpunkten speichern lassen, werden die meisten Grafikeffekte mithilfe sogenannter Appearance-Objekte erzeugt. Dieses beschreibt die allgemeinen Attribute der Oberfläche, insbesondere die visuellen Eigenschaften, eines Gegenstandes. Dadurch bekommt man auch eine gewisse Kontrolle über den Rendering-Prozess. Jedes Shape3D- und Primitive-Objekt verfügt über seine entsprechende Appearance. Dabei kann diese mehrere Subklassen der abstrakten NodeComponent-Klasse referenzieren, in denen die eigentlichen Eigenschaften gespeichert sind. Da ein Appearance-Objekt auf folgende Attribut-Objekte verweisen kann, wird es oftmals auch als Appearance-Bundle bezeichnet: PointAttributes LineAttributes PolygonAttributes ColoringAttributes TransparencyAttributes RenderingAttributes Material TextureAttributes Texture TexCoordGeneration Abb.7: Kontext des Appearance-Objektes. Aus: [4] 19

20 Bei Verwendung des Standard-Konstruktors Appearance myapp=new Appearance ; sind u.a. folgende Default-Werte eingestellt: Punkte und Linien werden jeweils in der Farbe Weiß in einer Stärke von einem Pixel gezeichnet. Des weiteren sind Transparenz und Antialiasing¹ deaktiviert. Um das entsprechend zu ändern, stehen umfangreiche Methoden zur Verfügung, auf einige wird in der nachfolgenden Erklärung der appearance attributes auch eingegangen: 1. PointAttributes Die Klasse PointAttributes beschreibt, wie Punkt-Primitive gerendert werden. Normalerweise füllt ein Vertex, das als Punkt gerendert wird, genau ein Pixel, was natürlich auch änderbar ist (setpointsize). 2. LineAttributes Die Klasse LineAttributes beschreibt, wie eine Linie gerendert wird. Die Größe ist auch hier wiederum variierbar (setlinewidth). 3. PolygonAttributes Die Klasse PolygonAttributes beschreibt durch die Rasterung eines Polygons, durch das Culling-Verhalten und einen speziellen Tiefen-Abstand, wie ein Polygon gerendert wird. Bei der Rasterung (setpolygonmode) hat man die Möglichkeiten, ein Polygon ausgefüllt (POLYGON_FILL), nur im Wireframe (POLYGON_LINE) oder nur die Eckpunkte (POLYGON_POINT) darzustellen. Mit dem Culling-Verhalten (setcullface) kann man eine Polygonseite ausblenden und so die Anzahl der zu rendernden Polygone reduzieren (CULL_FRONT, CULL_BACK, CULL_NONE). Da Vertices, die als Wireframe gerendert werden, nicht die exakt gleichen Tiefenwerte besitzen, wie die gleichen, die gefüllt gerendert werden, kann es zu dabei unerwünschten Nebeneffekten kommen (setpolygonoffset). 4. ColoringAttributes Die Klasse ColoringAttributes definiert, wie ein Objekt farblich dargestellt wird. Dabei sind am bedeutensten die Spezifikation der eigentlichen Farbe (setcolor) und die des Schattierungsmodels (setshademodel). Möglich ist hier im Wesentlichen ein Schattierungsmodel, welches zwischen den einzelnen Polygonen interpoliert (SHADE_GOURAUD), oder eines, bei dem an den Polygonkanten harte Übergänge entstehen (SHADE_FLAT). 5. TransparencyAttributes Die Klasse TransparencyAttributes beschreibt die Transparenz eines Objektes. Dazu muss festgelegt werden, ob und welche Art ausgeführt wird (settransparencymode). Möglich sind hier u.a. interpolierte Transparenz (BLENDED) und Screen-Door-Transparenz (SCREEN_DOOR). Zusätzlich muss noch ein Transparenzkoeffizient in Form eines float- Wertes zwischen 0 und 1 angegeben werden (settransparency). ¹ Technik zur Verminderung von unerwünschten Effekten (Alias-Effekt, Treppeneffekt). Dabei werden die Bildinhalte nicht nur am Pixel, sondern auch an anderen Positionen ausgewertet und in die Berechnung der Pixelfarbe mit einbezogen (Kantenglättung). 20

21 6. RenderingAttributes Die Klasse RenderingAttributes kontrolliert mit dem Tiefenpuffer- und Alpha-Test zwei unterschiedliche per-pixel rendering -Operationen. 7. Material Die Klasse Material spezifiziert Eigenschaften der Materialoberfläche des Objektes. Dabei besteht die Möglichkeit, verschiedene Farbwerte, die im Wesentlichen das Reflexionsverhalten des zugehörigen 3D-Objektes charakterisieren, zu setzen. Konkret umgesetzt wird diese Fähigkeit durch ambient, diffuse, specular und emissive Farbangaben sowie einem shininess Wert, welche alle jeweils über den Konstruktoraufruf oder im Nachhinein mittels Methoden (z.b. setdiffusecolor) zugewiesen werden können. Die ersten drei werden vom Lightning-Model zur Berechnung der Reflexion benutzt, die emissive-farbe legt fest, in welcher Farbe das Objekt unabhängig von anderen Lichtquellen erscheinen soll. Im Gegensatz zu den vier Farbspezifikationen, bei denen eine Farbe in Form der bekannten RGB-Werte übergeben wird, wird beim shininess-wert ein Faktor festgelegt, der den Glanzwert des Objektes angibt. Neben den Materialfarbangaben besteht, wie bereits schon erwähnt, die Möglichkeit, über die ColoringAttributes oder per Vertex-Spezifikation eine Farbe zuzuordnen. Dabei ist zu beachten, dass die Material-Angaben nur bei beleuchteten Objekten Verwendung finden, die ColoringAttributes hingegen nur bei unbeleuchteten. Des weiteren haben per Vertex- Geometrie-Farbangaben Vorrang zu den übrigen beiden. 8. TextureAttributes, Texture, TexCoordGeneration Die Klasse Texture dient dazu, durch Bilder oder Grafiken, die man auf die Oberfläche eines Objektes aufbringt, komplexere Strukturen nachzubilden, um so einer Szene eine realistischere Darstellung zu verleihen. Texturen können bspw. im einfachsten Fall anstelle einer einzelnen Farbe für einen Farbverlauf oder ein Muster verwendet werden, aber auch um Maserungen oder Strukturen darzustellen. In Java 3D muss zunächst die Textur als Bild aus einer Datei geladen werden. Das geschieht mittels eines Objektes der Klasse TextureLoader, welche als Teil des Utility- Hilfspakets beispielsweise das.jpg und.gif-format unterstützt. Anschließend muss die geladene Datei in ein Objekt vom Typ ImageComponent2D umgewandelt werden (getscaledimage). Dabei muss angegeben werden, auf welche Größe, also Breite und Höhe, die geladene Datei skaliert werden soll. Der Optimierung halber sollten hier Angaben in Zweierpotenzen erfolgen. Um als Textur eines sichtbaren Objektes zu dienen, muss das eben erzeugte Objekt vom Typ ImageComponent2D als Textur in ein Objekt vom Typ Texture2D, also bereits vom Typ Texture, geladen werden. Hierbei sind eine Reihe von unterschiedlichsten Parametern möglich, auf die hier nicht näher eingegangen werden soll. Der Grund für den Extraschritt über das ImageComponent2 zum Texture- Objekt ist ein ImageObserver, also eine Art Überwachung des Ladevorganges der Grafik, der optional angegeben werden kann. Danach können mit der Klasse TextureAttributes diverse Einstellungen bzgl. der Textur vorgenommen werden. So kann z.b. angegeben werden, wie oft die Textur aufgetragen wird, ob die zuvor getätigten Material- und Farbangaben mit einbezogen (MODULATE) oder verworfen werden (REPLACE) usw. Mit Hilfe des TexCoordGeneration-Objektes wird schließlich festgelegt, wie die Textur auf ein 3D-Objekt aufgetragen wird. Hier besteht u.a. die Möglichkeit zum linearen Auftragen (OBJECT_LINEAR, EYE_LINEAR), aber auch zum Auftragen auf eine Kugel (SPHERE_MAP) sowie einer Angabe, ob es sich um eine zwei- oder dreidimensionale 21

22 Textur handelt (TEXTURE_COORDINATE_2, TEXTURE_COORDINATE_3). Natürlich ist auch die manuelle Angabe von Texturkoordinaten weiterhin möglich, jedoch wird man insbesondere bei komplexeren Objekten ein TexCoordGeneration-Objekt bevorzugen. Des weiteren kann man mit der Texture-Klasse auch detailliert angeben, wie die Textur zu einzelnen Ecken einer durch Dreiecke modellierten Oberfläche zugeordnet werden sollen, sodass die Möglichkeiten der Verwendung wenig beschränkt sind. Auch Hintergrundbilder lassen sich auf diese Weise unter Zuhilfenahme eines Objektes vom Typ Background und eines Wirkungsbereiches verwenden. Es darf zum Ende der Anpassungen durch die oben genannten Klassen natürlich nicht vergessen werden, die getätigten Änderungen über die entsprechenden Methoden der zugehörigen Appearance bekannt zu machen. 7 Bewegungen in Java 3D Bisher wurden in dieser Abhandlung nur statische dreidimensionale Welten betrachtet. Um dynamisch veränderliche Szenen zu beschreiben, können Bewegungen als schrittweise Interpolation oder Konvexkombination zwischen Positionen oder Zuständen realisiert werden. An dieser Stelle wird in Java 3D streng zwischen Animation und Interaktion unterschieden. Animation stellt eine Veränderung im Szenengraphen dar, die nicht vom Benutzer beeinflusst wird und meist von zeitlichen Veränderungen ausgelöst wird, wohingegen einer Interaktion eine Aktion des Benutzer vorausgegangen ist. Obwohl diese beiden unterschieden werden, bedienen sie sich jedoch beide den sogenannten Behavior-Klassen. Die Klasse Behavior ist eine abstrakte Klasse, die den Mechanismus liefert, den Szenengraphen zur Laufzeit bearbeiten zu können. Des weiteren ist bei derer Verwendung von Vorteil, dass sie mit einem visuellen Objekt assoziiert werden, wodurch ihre Attribute automatisch angepasst werden. Darüber hinaus können sie nach eigenem Belieben selbst entworfen werden. 7.1 Animation Eine weitere Differenzierung erfolgt in Java 3D in der Art der Animationserstellung. Zum einen kann eine Manipulation des Szenengraphen mittels der abstrakten Klasse Interpolator, genauer durch derer Unterklassen, in Zusammenspiel mit der Klasse Alpha erfolgen. Zum anderen können die Klassen Billboard und Level of Detail (LOD) das Sichtfeld auf den Szenengraphen ändern, was hier jedoch vernachlässigt werden soll. Für die Erstellung von zeitbasierten Animationen finden die erwähnte Klasse Interpolator und die Klasse Alpha Verwendung. Das Alpha-Objekt Ein Alpha-Objekt produziert einen sich über den Zeitverlauf ändernden Wert, den alpha value, der zwischen inklusive 0 und 1 liegt. Betrachten man den Verlauf des alpha values über die Zeit, ergibt sich ein wellenförmiger Verlauf mit folgenden vier Phasen: steigender alpha value alpha value bei 1 fallender alpha value alpha value bei 0 22

23 Abb.8: Phasen des alpha values über die Zeit. Aus: [3]:10 Animationen Zusammen bilden die vier Phasen einen Durchlauf, dessen Dauer in einem integer-wert in Millisekunden spezifiziert wird. Aufgrund der vier Phasen ist auch die Parameteranzahl bei nicht default-konstruktoren durchschnittlich sehr hoch. Dadurch ist aber auch eine hohe Anpassungsmöglichkeit nach eigenem Belieben gegeben. So ist bei einem Konstruktor die Übergabe von zehn Parametern nötig. Es kann beispielsweise angegeben werden, ob nur der steigende, fallende oder beide Äste ausgeführt werden sollen sowie die jeweils zugehörigen Informationen wie eine Startzeit nach Programmstart, eine Phasenverzögerungszeit oder eine Beschleunigungszeit usw. Zur Vereinfachung wird nur folgender Konstruktor verwendet: Alpha alpha=new Alpha int loopcount,long increasingalphaduration ; Dabei gibt loopcount die Anzahl der zu durchlaufenden Arbeitszyklen, wobei ein Wert von -1 für unendliche Ausführungen steht, und increasingalphaduration die Dauer eines Arbeitszyklus an. Der Zyklus muss aber nicht alle Phasen der Welle durchlaufen, so wird z.b. beim obigen Konstruktoraufruf nur der ansteigende Ast durchlaufen. Alle anderen Werte werden dann mit default-werten besetzt. Der Interpolator Ein Interpolator-Objekt legt hingegen fest, welches Objekt auf welche Art animiert werden soll. Dazu bedarf es einer Beschreibung des zeitlichen Ablaufs einer Bewegung, was durch das Alpha-Objekt bereits realisiert wurde. Die abstrakte Klasse Interpolator hat über zehn Subklassen, die alle wie schon bereits erwähnt von der Behavior-Klasse abgeleitet sind. Im Folgenden eine Auswahl verfügbarer Interpolatoren: ColorInterpolator PathInterpolator PositionInterpolator RotationInterpolator ScaleInterpolator TransparencyInterpolator 23

24 Die Wirkungsweise der entsprechenden Interpolatoren ergibt sich dabei aus deren Namen. Sie unterscheiden sich jedoch in dem Objekt, auf das sie wirken sollen. Die Interpolatoren in der obigen Auswahl beziehen sich mit Ausnahme des ColorInterpolator und des TransparencyInterpolator auf eine TransformGroup. Hierbei ist jedoch darauf zu achten, dass man der entsprechenden TransformGroup die Möglichkeit gibt, dynamische Veränderungen zuzulassen. Das geschieht, wie in einem früheren Kapitel bereits erwähnt, mit Hilfe sogenannter Capabilities, welche man explizit setzen muss: TransformGrouptfGr=new TransformGroup ; tfgr.setcapability TransformGroup.ALLOW _TRANSFORM _ WRITE ; Im Folgenden ist die Erzeugung eines RotationInterpolator-Objektes dargestellt: RotationInterpolator ri=new RotationInterpolator alpha, tfgr,axis, startangle, endangle ; Dabei ist alpha ein bereits beschriebenes Objekt der Klasse Alpha, tfgr die Transformationsgruppe, auf die die Interpolation anzuwenden ist, und axis ein Objekt der Klasse Transform3D, welches eine Achse, entlang derer die Bewegung stattfinden soll, charakterisiert. Handelt es sich hierbei um die Identität, wird um die y-achse rotiert, was jedoch durch die Anwendung einer weiteren Transformation änderbar ist. Die beiden Parameter startangle bzw. endangle geben den Anfangs- bzw. Endwinkel der Rotation im Bogenmaß an. Wie gerade mittels Anfangs- und Endwinkels geschehen, speichern fast alle Interpolatoren zwei Werte, die als Endpunkte für die interpolierte Aktion gelten. Ist nun allgemein der alpha value 0, wird der erste der beiden Winkel verwendet, bei einem Wert von 1 der zweite Winkel. Dazwischen wird linear interpoliert. Nun muss wiederum noch ein Wirkungsbereich zugewiesen werden: ri.setschedulingbounds new BoundingSphere ; Abschließend muss neben der Transformationsgruppe mit dem zu bewegenden Objekt auch der Interpolator auf übliche Weise zum Szenengraphen hinzugefügt werden: BranchGroup objroot=new BranchGroup ; objroot.addchild ri ; Um mehr als nur die Veränderung von einzelnen Attributen der dreidimensionalen Objekte zu ermöglichen, gibt es mit der Morph-Klasse eine weitere Alternative. Mit dieser können komplette geometrische Objekte animiert werden. Ein Objekt vom Typ Morph erzeugt die Geometrie eines visuellen Objektes durch die Interpolation einer Gruppe von Objekten. Anders als die vorgestellte zeitbasierte und die blickwinkelbezogene Animation ist die Morph-Klasse nicht von der Behavior-Klasse abgeleitet, sondern direkt von Node, also kein Interpolator im beschrieben Sinn. 24

25 7.2 Interaktion Wie schon bereits erwähnt stellt eine Interaktion eine Reaktion einer Szene in Folge auf Benutzereingaben dar. Hierbei existieren im Wesentlichen sechs Möglichkeiten, damit ein Benutzer auf eine Szene Einfluss nehmen und diese dadurch ändern kann: Mausbewegung Mausklick Tastendruck Navigation Kollision Kombination dieser Möglichkeiten Änderungen von Szenen können beispielsweise durch Hinzufügen oder Entfernen von Objekten, durch derer Umordnung oder Standortänderung, durch Ändern der Attribute dieser oder durch Verändern von Transformationen von Objekten geschehen. Genauso wie bei der Animation findet auch bei der Interaktion die abstrakte Behavior- Klasse Verwendung, was auch aus den Namen der zu Interaktion zählenden Klassen ersichtlich ist. Abb.9: Die Klasse Behavior und deren Unterklassen. Aus: [3]: 8 Interaktionen Hauptmerkmal bei dieser Klasse ist eben, Szenenänderungen mittels Aktionen, z.b. ein Zeitlimit, eine Maus- oder Tastatureingabe oder eine Kollision, in einem vorher definiertem Bereich durchzuführen. Nur bei der Überschneidung dieses Bereiches mit der aktuellen ViewingPlatform werden diese Aktionen aktiviert. 25

26 Eine der am häufigsten verwendete Interaktion wird durch die OrbitBehavior-Klasse realisiert, nämlich die Bewegung der aktuellen Ansichtsposition, also des View, um ein Objekt. Dabei hat man die Möglichkeit, zu rotieren, zu translieren oder zu zoomen. Dies wird folgendermaßen durch ein Objekt vom Typ OrbitBehavior realisiert: OrbitBehavior orbit=new OrbitBehavior canvas3d ; Durch Angabe weiterer Parameter hat man verschiedene Einstellungsmöglichkeiten. So kann man z.b. das Bewegen durch Objekte hindurch verhindern, Bewegungen in oder entgegen der Mausbewegung durchführen usw. Dem Objekt muss nun noch ein Wirkungsbereich und der ViewingPlatform das Objekt zugewiesen werden, wobei simpleuniverse ein Objekt vom Typ SimpleUniverse ist: ViewingPlatform viewpl=simpleuniverse.getviewingplatform ; viewpl.setviewplatformbehavior orbit ; Weiter existieren noch Behavior, mit denen man den View selbst bewegen kann. So z.b. mittels der KeyNavigatorBehavior-Klasse in Kombination mit der KeyNavigator-Klasse sowie dem MouseUtilityBehavior-Package. Allgemein ist auch bei Interaktionen darauf zu achten, dass der Szenengraph den Bestimmungen des Behavior-Objektes entspricht. So benötigen einige Behaviors eine TransformGroup, bei der dann ggf. entsprechende Fähigkeiten explizit gesetzt sein müssen. Abschließend noch einen kurzen Blick auf die bereits erwähnte Möglichkeit, Behavior selbst zu schreiben. Dazu benötigt man zunächst ein Objekt, welches verändert werden soll. Des weiteren ist eine Methode initialize zu schreiben, die den TriggerEvent initialisiert und somit das Objekt über eine WakeUpCondition aufwachen lässt. Eine processstimulus -Methode gibt an, welche Änderungen am Objekt gemacht werden und auf welche Interaktion geändert wird. Schließlich wartet ein WakeupOnAWTEvent auf ein definiertes Signal, z.b. Maus- oder Tastatureingabe, und übergibt dieses. Falls dies erfolgreich war, wird dadurch die Änderung übernommen. 26