Erstellung geometrischer Figuren und Verwendung von Texturen in Java 3D

Transkript

1 Grafisch-Interaktive Systeme Prof. Dr. Heinzel Vertiefungsgebiet Embedded Systems Bachelor WS 2007 / 2008 Hochschule Fulda Erstellung geometrischer Figuren und Verwendung von Texturen in Java 3D Markus Falkner

2 Vorwort: Das folgende Tutorial soll dem Leser einen Einblick in die Erstellung einfacher und komplexer geometrischer Figuren und den Umgang mit Texturen in Java3D geben. Es ist grob in 2 Teile gegliedert: Kapitel 1 beschäftigt sich anfangs mit der Erstellung geometrischer Primitiven wie dem Würfel, dem Zylinder und der Kugel. Da man aber nur mit diesen Figuren alleine nicht viele Objekte aus der realen Welt nachbilden kann, wird im späteren Teil auf die Erstellung komplexer geometrischer Figuren eingegangen. Komplex in dem Sinne, dass die Figuren über eine Menge von Punkten definiert werden. Anschließend wird gezeigt, wie die Figuren skaliert, verschoben oder gedreht werden können. Viele Beispiele, die sich leicht selbst programmieren lassen, sollen die Anwendbarkeit veranschaulichen. In Kapitel 2 erfährt der Leser etwas über den Sinn und Zweck von Texturen und wie man sie in Java3D einsetzen kann. Am Anfang wird auf die verschiedenen Texturierungstechniken eingegangen und welche davon letztlich in Java3D vorhanden sind. Im Anschluss wird in einem Beispiel eine Textur auf eine einfach erstellte Figur aufgetragen. Zahlreiche Codefragmente und Bilder dienen der Anschaulichkeit. Wer höhere Anforderungen an die Texturierung stellt, erhält ein Übersicht über die Möglichkeiten im letzten Teil des 2.Kapitels. Hier werden Techniken und Möglichkeiten zu detailreicheren Texturierung beschrieben. Für das Verständnis und den Einsatz von Java3D ist die Vertrautheit und der sichere Umgang mit dem objektorientierten Paradigma von Java erforderlich, da in den Erläuterungen nicht weiter auf die Spezifikationen von Java eingegangen wird. Desweiteren sollte das Szenengraphen Konzept von Java3D und deren Anwendung bekannt sein. Bei diesem Tutorial handelt es sich um eine Ausarbeitung im Rahmen der Lehrveranstaltung Grafisch-Interaktive Systeme bei Prof. Dr. Heinzel im Wintersemester 2007 / 2008 an der Hochschule Fulda. Die folgenden Werkzeuge wurden für die Erstellung des Tutorials eingesetzt: - Sun Microsystems Java 6 JDK ( - Java3D Version 1.5 ( - Eclipse Version ( - Sun Microsystems OpenOffice ( Seite 2

3 Inhaltsverzeichnis Kapitel 1: Geometrische Figuren 1.1 Klassenhierarchie in Java3D Geometrische Primitiven Einführung Box(Cube) Kugel(Sphere) Zylinder(Cylinder) Vektoralgebra in Java3D Tupel Punkte Vektoren 18 Kapitel 2: Texturen 2.1 Definitionen Klassenhierarchie Verwendung von Texturen Fortgeschrittene Texturierung 24 Kapitel 3: Fazit Kapitel 4: Literaturverzeichnis 26 Kapitel 5: Abbildungsverzeichnis.. 27 Kapitel 6: Anhang Seite 3

4 1 Geometrische Figuren 1.1 Klassenhierarchie Um eine 3D Szene erstellen zu können, ist es natürlich wichtig 3D Objekte in die Szene einzufügen. Java 3D bietet in seiner Standardbibliothek einige primitive geometrische Figuren an, die in fast jeder komplexeren 3D Szene benutzt werden. Wie man diese Objekte erstellt wird in Abschnitt 2 dieses Kapitels beschrieben. Desweiteren bietet Java3D aber auch Werkzeuge zur Erstellung selbstdefinierter Figuren an, etwa über die Definition eigener Punkte im Raum, die dann durch Linien miteinander verbunden werden. Selbstverständlich ist es auch wichtig, Figuren drehen, verschieben und skalieren zu können. Wie man all diese macht wird in Abschnitt 3 dieses Kapitels behandelt. Um einen groben Überblick über die in Kapitel 1 dieses Tutorials behandelten geometrischen Figuren zu bekommen, ist es vielleicht ganz nützlich sich ein Bild von den benötigten Klassen in der Java3D - Bibliothek zu machen. Abbildung 1.1: Klassenhierarchie Java3D - Geometrische Primitive & Vektoren Seite 4

5 Die Eigenschaften von geometrischen Figuren werden im contentbranch des Szenengraphen festgelegt. Man benutzt also Subklassen der Superklasse Group, die wiederum Node als Superklasse besitzt. 1.2 Geometrische Primitiven Eine geometrische Figur fasst man in der modernen Mathematik als eine Menge von Punkten der Zeichenebene auf. Damit steht in der Geometrie die in der Mathematik übliche Mengensprechweise zur Verfügung. Als "primitive" Elemente [ ] verwendet man Punkte, Geraden und Ebenen. Alle anderen geometrischen Begriffe, wie Kreise, Winkel usw. lassen sich aus den "primitiven" Elementen evtl. mit Hilfe weiterer Definitionen (Abstand) beschreiben bzw. definieren. [vgl. /BEHRENS07/] Aus diesen primitiven Elementen können wiederum primitive geometrische Körper gebildet werden, die den meisten noch aus der Schulmathematik bekannt sein sollten. Diese werden im Folgenden als Geometrische Primitive bezeichnet. Es handelt sich dabei um die Figuren Quader bzw. Würfel, Kreis, Zylinder, Ring etc. Sie alle lassen sich in komplexeren Figuren wiederfinden. Jedes etablierte 3D Modellierungs und Animationsprogramm bietet zum Arbeiten eine Palette an geometrischen Primitiven an. So auch Java3D. Mit einigen dieser Primitiven beschäftigen sich die folgenden Unterkapitel Box Eine der wohl bekanntesten geometrischen Figuren ist die Box (übersetzt: Kasten). Streng mathematisch genommen, handelt es sich hierbei um einen Quader bzw Würfel. Die Klasse com.sun.j3d.utils.geometry.box stellt verschiedene Konstruktoren für die Erstellung eines Box-Objektes zur Verfügung. Seite 5

6 Der Aufruf des leeren Konstruktors erzeugt ein Box-Objekt mit der Dimension von 1 in x,y und z-richtung, also einen Würfel. Box() Es ist aber natürlich auch möglich die Dimensionen der Box selbst anzugeben. Man erhält zudem die Möglichkeit, ein Objekt zu übergeben, welches das Erscheinungsbild der geometrischen Primitive beschreibt. Ein solches Appearance Objekt definiert unter anderem eine Reihe von Attributen (Polygonattribute, Transparenzattribute, Farbattribute usw.), die sich auf die geometrische Figur beziehen sollen, aber auch Dinge wie Texturen oder Material. Dieses Appearance Objekt spielt in Kapitel 2 eine entscheidende Rolle, wo es um die Erstellung von Texturen geht. Box(float xdim, float ydim, float zdim, Appearance ap) Ein anderer Konstruktor lässt, neben dem zuvor genannten, noch die Berücksichtigung gewisser Flags zu, die in Java3D als Konstanten definiert sind. Hierzu zählt bspw. die Konstante GEOMETRY_NOT_SHARED, die man bei der Erzeugung eines Box-Objektes im Konstruktor als Flag angeben kann, wenn man verhindern möchte, dass das erzeugte Box-Objekt auch von einem anderen Szenengraphen-Knoten gemeinsam benutzt werden darf. In Java3D wird die Geometrie von identischen Figuren nur einmal gespeichert. Daher bewirkt die Veränderung bei nur einer geometrischen Primitive, dass sich die Veränderung auch auf andere Primitiven mit identischen Parametern überträgt. Box(float xdim, float ydim, float zdim, int primflags, Appearance ap) Um eine Box zu erzeugen, geht man wie folgt vor: 1. Am besten ist es, sich zuerst eine Methode anzulegen, welche das Erscheinungsbild (Appearance) der geometrischen Figur festlegt. In den folgenden Beispielen als myappearance() bezeichnet. In dieser Methode definiert man die Attribute wie z.b. die Farbe oder wie die einzelnen Polygone Seite 6

7 mit einander verbunden werden sollen (Nähere Informationen dazu liefert die Klasse javax.media.j3d.polygonattributes). Die Farbe einer Figur kann man über ein Objekt der Klasse ColorAttributes festlegen. Bei der Erzeugung dieses Objektes muss auch der zu benutzende Shader angegeben werden. Beispiel Code: private Appearance myappearance() //Appearence - Objekt erzeugen Appearance appearance = new Appearance(); //Attribut-Objekt erzeugen PolygonAttributes polyattrib = new PolygonAttributes(); // Farbobjekt erzeugen mit Farbe grün Color3f mycolor3f = new Color3f(0.8f, 0.0f, 0.2f); // Shader festlegen ColoringAttributes colorattrib = new ColoringAttributes(myColor3f, ColoringAttributes.NICEST); //Attribut-Objekt mit set-methoden belegen //(hier Polygonmodell ist nur mit Linien) polyattrib.setpolygonmode(polygonattributes.polygon_fill); appearance.setpolygonattributes(polyattrib); appearance.setcoloringattributes(colorattrib); return appearance; Quellcode 1.1: Methode myappearance() in Klasse SimpleBox() 2. Als nächstes ist es erforderlich, gemäß des vordefinierten Java3D Szenengraphen, eine Methode createscenegraph() zu definieren, die ein BranchGroup Objekt zurückliefert. Dieses Objekt wird später gebraucht, um es in ein vordefiniertes Universum zu integrieren. public BranchGroup createscenegraph() BranchGroup objroot = new BranchGroup(); //Box wird erzeugt mit Größenangaben und speziellen Einstellung für die Erscheinung*/ Box myobj = new Box(0.5f, 0.4f, 0.2f, myappearance()); //Geometrie-Objekt zur Transformations-Group hinzufügen objroot.addchild(myobj); return objroot; Quellcode 1.2: Methode createscenegraph() in Klasse SimpleBox() Seite 7

8 3. Zu guter letzt müssen noch ein paar Einstellungen bezüglich des Universums und des Applets gemacht werden, in welchem die Java3D Szene erscheinen soll. Diese Einstellungen können direkt im Konstruktor gemacht werden. Da aber hier ein Applet verwendet wird, ist es schöner solche Dinge in einer init() Methode zu definieren, da diese stets vor dem Konstruktor aufgerufen wird. public void init() setlayout(new BorderLayout()); GraphicsConfiguration config = SimpleUniverse.getPreferredConfiguration(); Canvas3D c = new Canvas3D(config); add("center", c); BranchGroup scene = createscenegraph(); scene.compile(); SimpleUniverse u = new SimpleUniverse(c); u.getviewingplatform().setnominalviewingtransform(); u.addbranchgraph(scene); Quelltext 1.3: Methode init() der Klasse SimpleBox() Compiliert man jetzt die Java Datei und führt sie aus, erhält man hoffentlich folgendes: Abbildung 1.2: SimpleBox Applet Der vollständige Quellcode ist im Anhang als Anlage A1 einsehbar. Seite 8

9 1.2.2 Kugel (Sphere) Das gleiche Verfahren wendet man für jede andere der 4 Geometrischen Primitiven an. In diesem Fall auch für die Kugel. Der Konstruktor für eine Kugel unterscheidet sich nicht groß von dem für eine Box. Neben dem einfachsten, bei dem nur der Radius angegeben wird, gibt es auch hier Konstruktoren bei denen man ein Appearence Objekt übergeben kann um das Gestaltungsbild der Kugel zu beschreiben. Daneben ist es auch möglich so genannte primflags festzulegen (Bedeutung siehe Box). Entscheidender Unterschied ist aber Angabe von Unterteilungen Divisions der Kugel. Je größer die Anzahl an Unterteilungen, desto runder wirkt die Kugel, aber auch desto mehr Polygone enthält die Figur. Das die Kugel bei größerer Anzahl an Unterteilungen runder wirkt, rührt daher das die Polygone untereinander mit Linien verbunden werden. Je mehr Punkte auf einer Krümmung mit geraden Linien verbunden werden, desto runder wirkt sie. Sphere(float radius, int primflags, int divisions, Appearance ap) Im folgenden Beispiel soll diesmal aber nicht nur eine platte und starre Kugel gezeichnet werden. Eine Bewegung der Objekte erfreut den Benutzer und zeigt zugleich, dass man Java3D auch sehr gut für Animationen benutzen kann. In diesem Fall wird auf ein RotationInterpolator Objekt zurückgegriffen, mit dem es möglich ist Objekte, zu drehen. Die RotationInterpolator Klasse ist eine Subklasse von Behavior. Daraus lässt sich ableiten, dass ein RoationInterpolator - Objekt das Verhalten (engl. Behavior) einer Figur steuert. Damit man die Geschwindigkeit und Häufigkeit der Umdrehungen der Kugel steuern kann, wird noch ein Objekt der Klasse Alpha benötigt. Mit diesem Objekt legt man die Anzahl der Wiederholungen der Umdrehungen und deren Geschwindigkeit fest. Darüber hinaus wird eine Gruppe von Figuren benötigt, auf die eine Transformation ausgeführt werden soll. Dieser TransformationGroup können mehrere Figuren, mittels der aus der Superklasse Group abgeleiteten addchild() Methode, zugeordnet werden. Schritt für Schritt erklärt, geht man wie folgt vor: Seite 9

10 1. Zuerst legt man sich wieder eine Methode an, welche das Erscheinungsbild der Figur beschreiben soll (Definition einer Methode die ein Objekt vom Typ Appearance zurückgibt. Siehe Beispiel Box) 2. Die Methode, welche den Szenengraphen erstellt, wird um einige Dinge erweitert, als sie schon für die Box definiert wurde. Die Erweiterungen sehen wie folgt aus: (1) Man fügt ein Objekt der Klasse TransformGroup ein, dem man erlaubt die Transformationsmatrizen der in ihm zusammengefassten Figuren selbst zu verändern. (Capability : ALLOW_TRANSFORM_WRITE) (2) Man erzeugt ein Objekt der Klasse Alpha, das als Parameter die Anzahl der Wiederholungen und die Geschwindigkeit für eine Transformation übergeben bekommt. (3) Schließlich erzeugt man ein RotationInterpolator, der das Alpha und das TransformGroup Objekt als Parameter übergeben bekommt. (4) Zu guter letzt definiert man noch einen Bereich (Bound), in dem die Transformation wirksam sein soll. Java3D bietet hier Klassen wie BoundingSphere oder BoundingBox an. Bzgl. Der Unterschiede zwischen den 2 Bounds wird auf die Java3D API verwiesen. Die neue Methode zur Erstellung des Szenengraphen (hier createscenegraph() genannt) sieht dann wie folgt aus: Seite 10

11 private BranchGroup createscenegraph() /* Wurzel des Content Branch-Graphen erzeugen */ BranchGroup objroot = new BranchGroup(); /* 1. Erzeugung einer TransformGroup */ TransformGroup objspin = new TransformGroup(); /* Erzeugung einer Kugel (Sphere) */ Sphere myobj = new Sphere(0.5f, myappearance()); /* a) Setzen des ALLOW_TRANSFORM_WRITE Flags */ objspin.setcapability(transformgroup.allow_transform_write); /** * Zu dieser Gruppe wird jetzt die Kugel hinzugefuegt **/ objspin.addchild(myobj); /** 2. Erzeugung eines Alpha-Objektes * -1 bedeutet, das die Drehung unendlich ausgefuehrt wird * 3000 entspricht 3000 millisekunden = 3 Sekunden fuer eine * Drehung */ Alpha rotationalpha = new Alpha(-1, 3000); /* 3. Erzeugung des RotationInterpolator-Objektes */ RotationInterpolator rotator = new RotationInterpolator(rotationAlpha, objspin); /** * Ein BoundingSphere definiert ein Gebiet (Kugel), in dem * ein Verhalten aktiv ist. Standardausrichtung ist der *Ursprung * mit einem Radius von 1.*/ BoundingSphere bounds = new BoundingSphere(); rotator.setschedulingbounds(bounds); objspin.addchild(rotator); objroot.addchild(objspin); return objroot; Quelltext 1.4: Modifizierte Methode createscenegraph() der Klasse FarbKugel 3. Man benötigt natürlich wieder ein Applet oder ein normales JFrame, in dem man das Java3D Objekt darstellen lässt. In diesem Beispiel wurde zur Abwechslung ein JFrame benutzt. Der vollständige Quellcode ist im Anhang als Anlage A2 einsehbar. Führt man das Programm aus, sollte man folgendes erhalten: Abbildung 1.3: Farbige Kugel (Sphere) Seite 11

12 1.2.3 Zylinder (Cylinder) Ein Zylinder ist laut Definition eine geometrische Figur, die aus 3 Flächen besteht (Grund-, Deck- und Mantelfläche), wobei die in parallelen Ebenen zueinander liegenden Deck- und Grundflächen, durch einen Mantel verbunden sind. Der bekannteste Zylinder ist wohl der Kreiszylinder, aber auch ein Prisma ist ein spezieller Zylinder. Bei den Kreiszylindern unterscheidet man noch zwischen geradem und schiefem Kreiszylinder. Bei der in Java3D implementierten primitiven geometrischen Figur Cylinder handelt es sich um einen geraden Kreiszylinder. Zum Zeichnen eines Zylinders benötigt man den Radius der Grund- bzw. Deckfläche und den Abstand (Höhe) zwischen den 2 Flächen. Cylinder(float radius, float height) Auch hier lässt sich wieder ein Apperance Objekt übergeben und die genannten primflags setzen Cylinder(float radius, float height, int primflags, Appearance ap) Da es sich hierbei wie bei der Kugel um Kreisflächen handelt, kann man auch hier die Anzahl an Punkten auf einem Kreis angeben, die durch Geraden miteinander verbunden werden, um eine stärkere Rundung zu erzielen. Diese Unterteilungen lassen sich sowohl in X, als auch Y Dimension einstellen. Daher, je mehr Unterteilungen in der X-Dimension, desto runder wirkt der Zylinder. Die Unterteilungen in der Y-Dimension geben quasi die Anzahl an Einzelzylindern an, aus welchen der Gesamtzylinder letztlich besteht. Cylinder(float radius, float height, int primflags, int xdivision, int ydivision, Appearance ap) Um die Vorteile der höheren Unterteilung in der X-Dimension sehen zu können, werden jetzt 2 verschiedenfarbige und verschieden positionierte Zylinder erzeugt: (1) Konstruktor und Main-Methode werden wie bei dem Beispiel für die Darstellung der Kugel angelegt. (2) Es werden 2 Appearance Methoden angelegt, die jeweils die verschiedenen Darstellungen beschreiben sollen (in diesem Fall unterschiedliche Farben) Seite 12

13 (3) Die Methode zur Erzeugung des Szenengraphen wird in der Weise gestaltet, dass a. Ein Transform3D Objekt zur verschiedenen Ausrichtung der Figuren benutzt wird b. Für jede der 2 Figuren eine Translation, die Figur wird jeweils an einer anderen Position im Universum dargestellt, durchgeführt wird. Dies geschieht mittels der Methode settranslation(vector3f), welche auf das zuvor erzeugte Transform3D Objekt angewendet wird. c. Man schließlich noch für jede Figur ein Transformgroup-Objekt erzeugt, das als Parameter jeweils das Transform3D Objekt erhält. d. Man 2 Zylinder erzeugt, mit gleichem Radius, gleicher Höhe, gleicher primflags und gleicher Y-Dimension, aber mit unterschiedlichem Erscheinungsbild und unterschiedlicher X-Dimension. e. Am Ende die erzeugten Zylinder-Objekte der Transformgroup hinzugefügt werden, welche letztlich in den ContenBranch eingegliedert werden. private BranchGroup createscenegraph() /* Wurzel des Content Branch-Graphen erzeugen */ BranchGroup objroot = new BranchGroup(); Transform3D t3d = new Transform3D(); TransformGroup objspin = null; /**************** 1. Objekt ********************/ /* Objekt verschieben um 0.6 in negative X-Richtung, 0.6 nach hinten*/ t3d.settranslation(new Vector3f(-0.6f, 0.0f, -0.6f)); objspin = new TransformGroup(t3d); /* Zylinder 1 erzeugen mit 6 Pkt in der X-Dimension */ Cylinder myobj = new Cylinder(0.4f, 0.9f, Cylinder. GEOMETRY_NOT_SHARED, 6,5, myappearance()); objspin.addchild(myobj); objroot.addchild(objspin); /**************** 2. Objekt ********************/ /* Objekt verschieben um 0.6 in positive X-Richtung, 0.6 nach hinten*/ t3d.settranslation(new Vector3f(0.6f, 0.0f, -0.6f)); objspin = new TransformGroup(t3d); /* Zylinder 2 erzeugen mit 50 Pkt in der X-Dimension*/ Cylinder myobj2 = new Cylinder(0.4f, 0.9f, Cylinder. GEOMETRY_NOT_SHARED, 50,5, myappearance2()); objspin.addchild(myobj2); objroot.addchild(objspin); return objroot; Quelltext 1.5: Darstellung 2 Zylinder mit versch. Erscheinungen und X-Dimensionen Seite 13

14 Die Methoden myappearance() und myappearance2() sind aus dem Beispiel Quellcode für die rotierende Kugel übernommen und nur in ihrer Farbe modifiziert. private Appearance myappearance() Color3f mycolor3f = new Color3f(1.0f, 0.0f, 0.0f); // rot... Quellcode 1.6: Modifizierte myappearance() private Appearance myappearance2() Color3f mycolor3f = new Color3f(0.0f, 1.0f, 0.0f); // grün... Quellcode 1.7: Neue myappearance2() Hat man in beiden Appearance Methoden als Polygon Rastermodus POLYGON_FILL benutzt, sollte man folgende Ergebnisse erhalten. Abbildung 1.4: 2 Zylinder (FILL) Man sieht, dass der grüne Zylinder runder erscheint, als der rote. Den Grund dafür sieht man, wenn man mit dem Rastermodus POLYGON_LINE rendert. Abbildung 1.5: 2 Zylinder (LINE) Seite 14

15 In Abbildung 1.5 sieht man, das für die Kreisflächen beim roten Zylinder deutlich weniger Punkte zur Verfügung stehen. Da die einzelnen Polygone durch Linien miteinander verbunden werden, entstehen die zu sehenden Kanten. Beim grünen Trapez wurde eine bessere Abrundung durch Verwendung mehrerer Punkte für die Kreisflächen bewirkt. Der vollständige Code ist im Anhang als Anlage A3 verfügbar. 1.3 Vektoralgebra in Java3D Wie jeder bereits wissen dürfte, sind Polygone so genannte Vielecke. Jede Figur kann durch Polygone dargestellt werden, die untereinander mit Linien verbunden werden. Es entsteht ein sogenanntes Polygon-Netz (engl. Polygon-Mesh). Jedes durch n-punkte aufgebaut Polygon, wird durch ein n-tupel definiert. Die Position der Punkte im Universum wird wiederum mittels Vektoren beschrieben. Um Figuren zu erzeugen, die fernab der schon vorhandenen geometrischen Primitiven liegen, kann man eigene Polygon-Netze mittels der in Java3D mitgelieferten Vektoralgebraischen Werkzeuge, erstellen. Das Unterkapitel 1.3 gibt anhand einiger Beispiele, einen Einblick in die Komplexität im Umgang mit diesen Werkzeugen Tupel In der Mathematik benutzt man oft Tupel, wenn man eine geordnete Zusammenstellung von Objekten haben will. So ist bspw. das Ergebnis eines kartesischen Produktes eine Menge von Tupeln. Ein Tupel unterscheidet sich von einer Menge in der Hinsicht, das Mengen nicht geordnet sind. In einer Menge ist die Position der Elemente bzw. Anordnung unwichtig. Eine Menge A=2,3,4 ist gleich der Menge B=4,3,2. Mengen werden daher eigentlich nur genutzt um Elemente aufzuzählen. Man kann sich leicht vorstellen, dass die Angabe von Punkten in einem Koordinatensystem sich nicht mit einfachen Mengen definieren lässt. Es muss vorab eine Konvention geschaffen werden, welches Element in einer Menge, welche Dimension repräsentiert. Sprich, es ist erforderlich die Elemente anzuordnen, bzw. die Elemente einer Dimension zuzuordnen. Java3D bietet verschiedene abstrakte n-tupel Klassen an (2-Tupel, 3-Tupel, 4- Tupel), die in zahlreichen Subklassen implementiert werden. Folgende Abbildung zeigt die Implementationen der abstrakten Tupel-Klassen. Seite 15

16 Abbildung 1.6: Klassenhierarchie Java3D Vecmath (vgl. /MANG02/) Punkte Um eine Figur zu erzeugen, ist es natürlich wichtig, Punkte im Universum zu definieren, welche den Grundriss der Figur repräsentieren. Diese Punkte werden durch Koordinaten angegeben. Java3D bietet 2-, 3-, und 4-dimensionale Koordinaten Angaben an. In dem folgenden Beispiel werden ausschließlich 3-dimensionale Punkte benutzt. Die zur Verfügung gestellten Klassen Point3f, Point3d, Point3i bieten zahlreiche Konstruktoren zur Erstellung eines Punkt Objektes an. So kann man sowohl die x, y und z Koordinaten direkt übergeben, Point3f(float x, float y, float z) als auch in Form eines Arrays. Point3f(float[] p) Die Erstellung von Punkten reicht allerdings nicht aus, um daraus eine Figur zeichnen lassen zu können. Es wird noch zusätzlich ein so genanntes Geometry Array benötigt, in dem festgelegt wird, wie, ob und welche Punkte durch Linien miteinander verbunden werden sollen. Abbildung 1.7: Auswahl einiger Geometrie Arrays (vgl. /MANG02/) Seite 16

17 Im Anhang als Anlage A4 ist eine Klassenübersicht über die verfügbaren Geometrie Arrays einsehbar. Auf die Unterschiede zwischen den verschiedenen Arrays soll in diesem Tutorial nicht weiter eingegangen werden. In dem folgenden Beispiel soll ein selbstdefiniertes 3-dimensionales Dreieck gezeichnet werden. Als Vorlage dient hier wieder die Klasse FarbKugel, bei der die Methode createscenegraph() modifiziert wird. Vorgehen: (1) Zuerst muss ein neues BranchGroup Objekt erzeugt werden, da die zusammenhängenden Flächen ja am Ende eine Figur ergeben sollen. (2) Ferner müssen geeignete GeometryArray Objekte für die 5 Flächen deklariert werden (in diesem Beispiel 2 TriangleStripArrays und 3 QuadArrays) (3) Anschließend definiert man die einzelnen Punkte, durch welche die Figur repräsentiert werden soll) (4) Danach erstellt man am besten zuerst die 2 Dreiecksflächen, in dem man 2 Objekte vom Typ TriangleStripArrays erzeugt. Die 2 Dreiecke sollen jeweils 3 Punkte verbunden mit 3 Linien haben. (5) Mittels der Methode setcoordinate(int coord, float Point3f) legt man die Reihenfolge fest, in der die Punkte miteinander verbunden werden sollen. (6) Die Schritte 4-5 wiederholt man für die 3 QuadArrays. (7) Jetzt braucht man nur noch die entsprechenden Shape3D Objekte erzeugen, die als Argumente die jeweils definierten GeometryArrays erhalten. (8) Zum Schluss fügt man mit der Methode addchild() die erzeugten Shape3D Objekte der in Punkt (1) erzeugten BranchGroup hinzu. Bei Ausführung sollte man folgendes Bild erhalten: Abbildung 1.8: 3D Dreieck mit Point3f Seite 17

18 Der vollständige Quellcode ist im Anhang als Anlage A5 zu finden Vektoren In der Mathematik wird der Vektor als ein Element eines Vektorraumes über einem Körper definiert, wobei der Vektorraum gewisse Eigenschaften besitzt. Ein in diesem Vektorraum definierter Vektor besitzt einen Abstand und eine Richtung, in welche er zeigt. Vektoren werden deshalb oft als Pfeile dargestellt. Sie spielen in der Geometrie eine große Rolle und sind unerlässlich, wenn man bspw. den Abstand zweier Geraden oder zweier Flächen zueinander bestimmen möchte. So basiert z.b. das Backface Culling auf Vektoroperationen, um zu entscheiden, ob eine Seite eines Objektes (z.b. von einem Würfel) vom Augpunkt aus sichtbar ist oder nicht. Ist sie nicht sichtbar, braucht sie auch nicht gerendert zu werden. Auch für die Transformationsoperationen (Skalierung, Translation, Drehung) werden Vektoren benutzt. Schon in Kapitel wurde bei der Erstellung der 2 Zylinder ein Vektor zur Verschiebung (Translation) benutzt. Vektoren finden ihren Einsatz aber auch beim Hinzufügen zusätzlicher Lichtquellen oder Audioquellen zur Szene. Java3D stellt darüber hinaus natürlich auch Methoden für die Vektoralgebra, wie bspw. für die Berechnungen von Vektorprodukt, Kreuzprodukt oder Normalisierung eines Vektors, bereit. Dieses Kapitel widmet sich aber hauptsächlich der Verwendung von Vektoren zur Transformation von Figuren. Wie man der Abbildung 1.6 entnehmen kann, unterscheidet man zwischen Vektoren mit 2, 3 und 4 Koordinaten. Die Erzeugung eines Vector Objektes ist auf verschiedene Weisen möglich. Man kann entweder die Koordinaten direkt angeben oder in Form eines Arrays. Der Standard Konstruktor (leerer Konstruktor) erzeugt ein Vector Objekt mit den Koordinaten (0,0) für Vector 2f,2d bzw (0,0,0) für Vector 3f,3d bzw (0,0,0,0) für Vector 4f,4d. Beispiel Vector 3f: Vector3f() Constructs and initializes a Vector3f to (0,0,0). Vector3f(float[] v) Constructs and initializes a Vector3f from the array of length 3. Vector3f(float x, float y, float z) Constructs and initializes a Vector3f from the specified xyz coordinates. Seite 18

19 In dem folgenden Beispiel soll gezeigt werden, wie man die Vektoren für die Translation bzw. Skalierung einsetzen kann. Es werden 3 verschiedene Objekte (Kugel, Box, Zylinder) mit unterschiedlichen Farben erzeugt und an verschiedenen Koordinaten positioniert. Das Objekt, welches sich im Ursprung befindet, soll durch einen Vektor skaliert werden. Man geht am besten wie folgt vor: (1) Man legt für jedes Objekt, das man skalieren bzw. verschieben will, ein Vector3d oder Vector3f Objekt an. (2) Dann benötigt man für jede Transformation ein eigenes Transform3D Objekt, auf welches dann mit setscale() die Skalierung bzw. mit settranslation() die Verschiebung durch einen Vektor angegeben wird. (3) Anschließend legt man Gruppen fest die den Transformationen zugeordnet werden. Auf alle Objekte, die Mitglieder dieser Gruppe sind, wird die Transformation angewendet. (4) Nun erzeugt man die Figuren Zylinder, Box und Kugel und ordnet sie mit addchild() den Transformationsgruppen zu. (5) Die Transformationsgruppen werden letztlich wiederum mit addchild() der BranchGroup zugeordnet. Ein Beispielcode in dieser Form ist im Anhang als Anlage A6 einsehbar. Erzeugt werden ein grüner Zylinder, eine rote Kugel und eine blaue Box. Abbildung 1.9: 3 transformierte Figuren In diesem Beispiel wurden 3 verschiedene Vektoren verwendet, charakterisiert durch Vektor1, Vektor2 und Vektor3. Vektor1 beschreibt die Translation des grünen Zylinders um -0.5 in der X-Achse. Die rote Kugel wurde durch Vektor2 um den Faktor Seite 19

20 2 in der Y- und Z-Achse skaliert (vergrößert). Die blaue Box hingegen wurde durch Vektor3 um 1,5 in der X-Achse und 5 in der Z-Achse verschoben. Dadurch, das sich die Box räumlich gesehen weiter hinten befindet, wirkt sie auch kleiner als die anderen Figuren. Ohne die Verschiebung in den Hintergrund, wäre die Box die höchste Figur, wie man leicht testen kann. 2 Texturen 2.1 Einführung Der Begriff Textur leitet sich aus dem lateinischen Begriff textura ab, was übersetzt Gewebe heißt und die Struktur oder Zusammensetzung von Dingen beschreibt. In der 3D Modellierung versteht man unter einer Textur ein Bild, das auf eine Figur gelegt wird. Bei diesem Texture Mapping gibt es verschiedene Methoden, wie die Textur auf die Figur gelegt bzw. projiziert werden soll. Erst mit einer Textur ist es möglich Objekte aus der realen Welt möglichst realitätsnah zu gestalten, da über eine Textur z.b. nicht nur die Struktur, sondern auch das Glanzverhalten von Oberflächen gesteuert werden kann. Texturen können auch die Modellierung erleichtern, indem man bspw. bei der Modellierung eines Grashalmes eine Textur verwendet anstatt Vertiefung und Erhebung zu modellieren. Dies hat auch aus Perfomancegründen eine große Bedeutung. Es gibt eine Texturierungstechnik, bei der die Geometrie einer Figur passend verändert wird um eine höhere Detailtreue zu erzielen. Man spricht hierbei vom Displacement Mapping. Darüber hinaus gibt es die Technik des Bumpmappings, die bei extrem detailreichen Objekten benutzt wird um eine Oberflächenunebenheit zu simulieren. Die Textur dient hierbei als Speicher für Informationen, mit deren Hilfe Schattierungen auf eine Oberfläche gezeichnet werden. Es gibt noch zahlreiche andere Texturierungstechniken, die aber oft nur in professionellen 3D Modellierungsprogrammen verwendet werden. Seite 20

21 2.2 Klassenhirarchie Abbildung 2.1: Klassenhirarchie Texturierung Java3D 2.3 Verwendung von Texturen Die einfachste Art der Texturierung unter Java3D ist das Texture Mapping. Man benötigt für das Anbringen einer Textur die genauen Koordinaten, auf welche die Textur gelegt werden soll. Bei den in Java3D vorhandenen geometrischen Primitiven (vgl. Kapitel 1) kann man durch Angabe der Konstante GENERATE_TEXTURE_COORDS als PrimitiveFlag (Erläuterung siehe Seite 6) die Koordinaten für die Textur angeben. Erzeugt man dagegen Figuren über selbst definierte Geometrie Sammlungen (vgl. Kapitel 1.3), so muss man die Punkte selbst definieren, auf welchen die Textur angebracht werden soll. In dem folgenden Beispiel soll auf Grundlage der rotierenden Kugel aus Kapitel 1.2.3, eine Textur aufgebracht werden. Wie schon in den Beispielen zuvor, ist es nützlich eine Methode zu definieren, die sich um das Erscheinungsbild einer Figur kümmert. Strenge Modularisierung ist bei der Verwendung mehrerer geometrischer Figuren absolut notwendig, fördert aber auch schon bei wenigen Figuren die Übersichtlichkeit und Erweiterbarkeit. Seite 21

22 Um die aus Kapitel verwendete Kugel mit einer Textur zu versehen, eignet sich folgende Vorgehensweise. Alle Änderungen werden in der Methode myappearance() vorgenommen: (1) Man sucht oder erstellt sich ein passendes JPG oder GIF Bild, welches die Ausmaße von 2 n x 2 n Pixeln hat. Dabei kann die Höhe auch ein gerades Vielfaches der Breite sein und umgekehrt (bspw. 64x32 oder 128x256). Bilder, die nicht diesen Maßen entsprechen, werden falsch auf der Figur dargestellt. (2) Danach benötigt man ein TextureLoader Objekt, in welchem man auf die gespeicherte Bilddatei verweist. (3) Jetzt braucht man noch ein Texture2D Objekt um aus dem Bild eine geeignete Textur zu erstellen. Die in TextureLoader vorhandene Methode gettexture() liefert ein Objekt vom Typ Texture. Jetzt kann das Objekt einfach auf Texture2D gecastet werden, da Texture2D eine Subklasse von Texture ist. (4) Zuletzt weist man mit der Methode settexture() dem erzeugten Appearance Objekt die Textur zu. private Appearance myappearance() //Appearence - Objekt erzeugen Appearance appearance = new Appearance(); //Attribut-Objekt erzeugen PolygonAttributes polyattrib = new PolygonAttributes(); //Bild in den TextureLoader laden TextureLoader lader = new TextureLoader("earth.gif", this); //Texture2D-Objekt erzeugen aus dem TextureLoader Texture2D texturerde = (Texture2D)lader.getTexture(); //Attribut-Objekt mit set-methoden belegeb (hier Polygonmodell ist nur mit Linien) polyattrib.setpolygonmode(polygonattributes.polygon_fill); //AppearanceObjekt-Attribute setzen appearance.setpolygonattributes(polyattrib); appearance.settexture(texturerde); return appearance; Quellcode 2.1: myappearance() mit Texturerstellung Der vollständige Quellcode befindet sich im Anhang als Anlage A7 Seite 22

23 Man erhält hierdurch eine sich drehende Weltkugel. Abbildung 2.2: Rotierende Kugel mit Textur Gleiches Verfahren lässt sich auch bei anderen geometrischen Primitiven anwenden: Abbildung 2.3: Rotierender Kubus mit Logo der HS Fulda Bei der Texturierung von nicht primitiven geometrischen Figuren, muss etwas mehr Aufwand betrieben werden. Während bei diesen, mittels des Flags GENERATE_TEXTURE_COORDS, schon bei der Erzeugung Texturkoordinaten festgelegt wurden (siehe oben), so muss man diese Aufgabe bei nicht primitiven Figuren selbst übernehmen. Man nutzt hierfür Objekte der Klassen TexCoord2f, TexCoord3f oder TexCoord4f die Subklassen der jeweiligen Tupel Klassen sind (siehe Seite 16 Abbildung 1.6). Seite 23

24 Die TexCoord Klassen enthalten keine Methoden. Die Koordinaten müssen also schon bei Objekterzeugung übergeben werden. Um jetzt also einen eigenen Bereich festlegen zu können, auf den die Textur aufgetragen werden soll, muss man wieder auf ein GeometryArray zurückgreifen, wie er schon aus Kapitel bekannt sein sollte. Jedes GeometryArray Objekt verfügt über eine Methode settexturecoordinate() über die man die Koordinaten festlegt. Der folgende Codeausschnitt zeigt, wie man diese Texturkoordinaten festlegt. QuadArray plane = new QuadArray(4, GeometryArray.COORDINATES Geometry.TEXTURE COORDINATE 2); Point3f p = new Point3f(); p.set(-1.0f, 1.0f, 0.0f); plane.setcoordinate(0,p); p.set(-1.0f, -1.0f, 0.0f); plane.setcoordinate(1,p); p.set(1.0f, -1.0f, 0.0f); plane.setcoordinate(2,p); p.set(1.0f, 1.0f, 0.0f); plane.setcoordinate(3,p); Point2f q = new Point2f(); q.set(0.0f, 1.0f); plane.settexturecoordinate(0,q); q.set(0.0f, 0.0f); plane.settexturecoordinate(1,q); q.set(1.0f, 0.0f); plane.settexturecoordinate(2,q); q.set(1.0f, 1.0f); plane.settexturecoordinate(3,q); Quellcode 2.2: Festlegung von Texturkoordinaten (vgl. /ANGULANZA02/) Man kann leicht erahnen, dass die Texturierung von komplexen Figuren einen großen Aufwand mit sich bringt und eine gute Überlegung über die Vorgehensweise wichtig ist. 2.4 Fortgeschrittene Texturierung Java3D bietet zahlreiche Einstellungen und Funktionen bei der Erstellung von Texturen und Materialien an. So gibt es auch eine Implementation des BumpMappings, das Dot3 BumpMapping. Wer sich näher damit auseinander setzen will, findet auf zahlreiche Hinweise und Tipps zum Umgang mit BumpMapping in Java3D. Java3D bietet die Möglichkeit, die Textur weiter zu spezifizieren. So kann man bspw. Seite 24

25 über ein Objekt der Klasse TexCoordGeneration festlegen, wie sich eine Textur auf einer Figur verhalten soll, wenn sich die Figur um sich selbst dreht. TexCoordGeneration(int genmode, int format) Constructs a TexCoordGeneration object with the specified genmode and format. Über den Parameter genmode lässt sich steuern, ob die Textur mit samt der Figur rotieren soll (Parameter OBJECT_LINEAR), nur das Objekt selbst unter der Textur rotieren soll (Parameter EYE_LINEAR) oder ob die Textur über Spherical Mapping auf die Figur gelegt werden soll (Parameter SPHERE_MAP). Beim Spherical Mapping, wird eine Kugel als Deformationsgrundlage genommen. Unter finden sich 3 Applets, die sich eingehend mit den verschiedenen Texturierungstechniken in Java3D beschäftigen. Die JAR Dateien sind auch im Beispielverzeichnis zu finden. Es kann auch mal öfters der Fall eintreten, dass die physikalische Textur kleiner ist, als die zu texturierende Figur. Um hier Abhilfe zu schaffen, bieten die Klassen Texture2D und Texture3D eine Methode setbounderymode() an um zu steuern, was im Falle des Eintretens des oben genannten Problems, passieren soll. Über die Methoden setbounderys(), setbounderyt() und setbounderyr() lässt sich das Verhalten der Textur für alle drei Dimensionen festlegen. Nähere Informationen dazu, findet man in der Java3D API. Mit Objekten der Klasse TextureAttributes lässt sich festlegen, wie und ob die Textur mit einer vorher eingefärbten Figur reagiert. Hat man bspw. eine rote Kugel und entscheidet sich dann, wie in Kapitel 2.3 beschrieben, eine Textur zu verwenden, so wird ohne Verwendung eines TextureAttributes-Objekt die vorher definierte Farbe überlappt. Durch die Methode settexturemode() wird festgelegt, ob die Farben von Texel (Bildpunkt in der Textur) und Pixel miteinander vermischt werden soll oder die Farbe vom Pixel gänzlich unterdrückt wird. Weitere Informationen über die verschiedenen Modi sind ebenfalls der Java3D API entnehmbar. Es ist auch möglich, mehrere Texturen auf eine Figur zu legen. Das kann z.b. dann nützlich sein, wenn man einen Lichtkegel auf einer Backsteinmauer dargestellt bekommen will o.ä.. Hierbei bietet es sich an, zuerst ein Backsteinmuster als Textur auf die Figur zu legen und anschließend darüber eine Lichtkegel-Textur. Ermöglicht wird dies in Java3D durch die Technik des MIP (multum in parvo = vieles im kleinen) Seite 25

26 Mappings. Bei der Erzeugung eines TextureLoader Objektes muss GENERATE_MIPMAP als Flag übergeben werden, um dieses Verfahren nutzen zu können. In diesem Tutorial soll aber nicht weiter auf diese Technik eingegangen werden. 3 Fazit Java3D ist eine durchaus effiziente und portable Symbiose aus Objektorientierter Sprache mit vielen Funktionen, die man schon aus OpenGL oder komplexen 3D Modellierungs- und Animationsprogrammen wie Maya oder Softimage XSI kennt. Ist man mit Java und dem Paradigma der Objektorientierung vertraut, findet man einen schnellen Einstieg in den Umgang mit Java3D. Hat man sich erst einmal an den Umgang mit dem Szenengraphen Verfahren gewöhnt, ist es einfach eine Vielzahl von Funktionen an Figuren zu testen. Die Anzahl an Hilfsmitteln für eine möglichst detailgetreue Darstellung ist relativ groß, dennoch aber weit unter denen von professionellen 3D Modellierungs- und Animationsprogrammen. Das Erstellen von eigenen geometrischen Figuren über die bereitgestellten Point Klassen, erfordert einen hohen Grad an Abstraktions- und Vorstellungsvermögen im dreidimensionalen Raum und mathematischen Kenntnissen im Bereich der Vektoralgebra. Daher war es aufgrund der unvorhersehbaren Komplexität nicht mehr möglich die ursprünglich geplante Implementation eines Ringes (Torus) in diesem Tutorial einzubauen. Aufgrund der doch recht kurzen Zeit zur Erstellung dieses Tutorials, war es zudem kaum möglich sich tiefergehend mit allen Funktionen auseinander zu setzen. Hinzu kam, dass man auch erst einmal den Umgang mit Java3D lernen und das Szenengraphenkonzept verstehen musste. Alle diese Faktoren trugen dazu bei, das die Beispiele gerade für Neulinge im Gebiet Java3D gemacht wurden um diesen einen guten Einblick in die Möglichkeiten zu zeigen, ohne überall ins Detail zu gehen. Seite 26

27 Wer sich schon gut mit OpenGL und Java auskennt, wird keine Probleme mit Java3D haben. Allen anderen sei das Erlernen beider Umgebungen, wenigstens in den Grundzügen, nahe gelegt. 4 Literaturverzeichnis /ANGULANZA02/: Angulanza, Florian et al.: Texturen in Java3D, In: cosy.sbg.ac.at, Erstellt: 2. Juli 2002, Abrufdatum: /BARTSCH02/: Bartsch, Axel: Lines, Shapes and Geometric Objects, In: hs-fulda.de, 20Objects.pdf, Erstellt: Oktober 2002, Abrufdatum: /BEHRENS07/ : Behrens, Hubertus: Geometrische Figuren, Abrufdatum: /MANG01/: Mangoldt, Th. und Kurht, W.: Java3D Einstiegs-Tutorial Teil 1, In: informatik.tu-cottbus.de, Erstellt: WS 2002/03, Abrufdatum: /MANG02/: Mangoldt, Th. und Kurth, W.: Java3D Einstiegs-Tutorial Teil 2, In: informatik.tu-cottbus.de, Erstellt: WS 2002/03, Abrufdatum: Seite 27

28 5 Abbildungsverzeichnis Abbildung 1.1: Java3D - Geometrische Primitive & Vektoren, Seite 4 Abbildung 1.2: SimpleBox Applet, Seite 8 Abbildung 1.3: Farbige Kugel (Sphere), Seite 11 Abbildung 1.4: 2 Zylinder (FILL), Seite 14 Abbildung 1.5: 2 Zylinder (LINE), Seite 14 Abbildung 1.6: Klassenhierarchie Java3D Vecmath, Seite 16 Abbildung 1.7: Auswahl einiger Geometrie Arrays, Seite 16 Abbildung 1.8: 3D Dreieck mit Point3f erstellt, Seite 17 Abbildung 1.9: 3 transformierte Figuren, Seite 19 Abbildung 2.1: Klassenhierarchie Texturierung Java3D, Seite 21 Abbildung 2.2: Rotierende Kugel mit Textur, Seite 23 Abbildung 2.3: Rotierender Kubus mit Logo der HS Fulda, Seite 23 Abbildung 2.4: Klassenhierarchie GeometrieArrays in Java3D, Seite 35 Seite 28

29 6 Anhang Anlage A1) /** * Klasse SimpleBox erzeugt ein Applet, auf dem eine farbige Box erscheint * Die Box wird mit Java3D gezeichnet. * 1.0 Markus Falkner */ import java.applet.applet; import java.awt.borderlayout; import java.awt.event.*; import java.awt.color.*; 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.*; public class SimpleBox extends Applet /** Konstruktor */ public SimpleBox() //eigene Methode für die Einstellungen des Erscheinungsbildes private Appearance myappearance() //Appearence - Objekt erzeugen Appearance appearance = new Appearance(); //Attribut-Objekt erzeugen PolygonAttributes polyattrib = new PolygonAttributes(); // Farbobjekt erzeugen mit Farbe grün Color3f mycolor3f = new Color3f(0.8f, 0.0f, 0.2f); // Shader festlegen ColoringAttributes colorattrib = new ColoringAttributes(myColor3f, ColoringAttributes.NICEST); //Attribut-Objekt mit set-methoden belegeb (hier Polygonmodell ist nur mit Linien) // mit *.POLYGON_FILL würde es gefüllt werden polyattrib.setpolygonmode(polygonattributes.polygon_fill); appearance.setpolygonattributes(polyattrib); appearance.setcoloringattributes(colorattrib); return appearance; public BranchGroup createscenegraph() BranchGroup objroot = new BranchGroup(); Seite 29

30 //Box wird erzeugt mit Größenangaben und speziellen Einstellung für die Erscheinung*/ Box myobj = new Box(0.5f, 0.4f, 0.2f, myappearance()); //Geometrie-Objekt zur Transformations-Group hinzufügen objroot.addchild(myobj); return objroot; public void init() setlayout(new BorderLayout()); GraphicsConfiguration config = SimpleUniverse.getPreferredConfiguration(); Canvas3D c = new Canvas3D(config); add("center", c); BranchGroup scene = createscenegraph(); //scene.compile(); SimpleUniverse u = new SimpleUniverse(c); u.getviewingplatform().setnominalviewingtransform(); u.addbranchgraph(scene); public static void main(string[] args) new MainFrame(new SimpleBox(), 500, 500); Anlage A2) /** * Programm: FarbKugel.java * * Erzeugung einer roten Kugel (Sphere), dessen Polygone mit Linien * verbunden sind. Die Kugel dreht um die Y-Achse nach rechts. * Markus Falkner 1.0 */ import java.awt.borderlayout; import java.awt.event.*; import java.awt.graphicsconfiguration; import javax.media.j3d.*; import javax.vecmath.*; import javax.swing.jframe; import com.sun.j3d.utils.universe.*; import com.sun.j3d.utils.geometry.sphere; import com.sun.j3d.utils.geometry.box; import com.sun.j3d.utils.geometry.cylinder; public class FarbKugel extends JFrame public static void main(string[] args) FarbKugel kugel = new FarbKugel(); Seite 30

31 /* WindowListener hinzufuegen */ kugel.addwindowlistener(new WindowAdapter() public void windowclosing(windowevent e) /* Beim Schliessen des Fenster, Programm beenden */ System.exit(0); ; ); public FarbKugel() /* Universum festlegen */ GraphicsConfiguration config = SimpleUniverse.getPreferredConfiguration(); Canvas3D canvas3d = new Canvas3D(config); /* Canvas3D Objekt zum Frame hinzufuegen */ this.getcontentpane().add(canvas3d,new BorderLayout().CENTER); /* Erzeugung eines SimpleUnviverse-Objektes */ SimpleUniverse universum = new SimpleUniverse(canvas3D); /** Anpassung des SimpleUniverse-Objektes: * setnominalviewingtransform() bewirkt, das der Augpunkt * auf (x,y,z) = (0,0,2.41) festgelegt wird (Siehe Java3D API) * getviewingplatform gibt die ViewingPlatfrom zurueck. * Man schaut also in negativer z-richtung. **/ universum.getviewingplatform().setnominalviewingtransform(); /* Erzeugung des Content Branch-Graphen */ BranchGroup scene = createscenegraph(); /* Content Branch-Graphen kompilieren */ scene.compile(); /* Content Branch-Graph dem SimpleUniverse-Objekt hinzufuegen */ universum.addbranchgraph(scene); /* Titel des JFrames setzen */ this.settitle("rotierende FarbKugel"); /* Groesse des JFrames setzen */ this.setsize(800,800); /* Frame anzeigen */ this.show(); private Appearance myappearance() //Appearence - Objekt erzeugen Appearance appearance = new Appearance(); //Attribut-Objekt erzeugen PolygonAttributes polyattrib = new PolygonAttributes(); TransparencyAttributes transparenz2 = new TransparencyAttributes(TransparencyAttributes.NICEST, 0.5f); // Farbobjekt erzeugen mit Farbe grün Color3f mycolor3f = new Color3f(0.8f, 0.0f, 0.2f); // Shader festlegen ColoringAttributes colorattrib = new ColoringAttributes(myColor3f, ColoringAttributes.NICEST); //Attribut-Objekt mit set-methoden belegeb (hier Polygonmodell ist nur mit Linien) // mit *.POLYGON_FILL würde es gefüllt werden polyattrib.setpolygonmode(polygonattributes.polygon_line); appearance.setpolygonattributes(polyattrib); appearance.settransparencyattributes(transparenz2); appearance.setcoloringattributes(colorattrib); return appearance; Seite 31

32 private BranchGroup createscenegraph() /* Wurzel des Content Branch-Graphen erzeugen */ BranchGroup objroot = new BranchGroup(); /* 1. Erzeugung einer TransformGroup */ TransformGroup objspin = new TransformGroup(); /* Erzeugung einer Kugel (Sphere) */ Sphere myobj = new Sphere(0.5f, myappearance()); /* a) Setzen des ALLOW_TRANSFORM_WRITE Flags */ objspin.setcapability(transformgroup.allow_transform_write); /** * Zu dieser Gruppe wird jetzt die Kugel hinzugefuegt **/ objspin.addchild(myobj); /** 2. Erzeugung eines Alpha-Objektes * -1 bedeutet, das die Drehung unendlich ausgefuehrt wird * 3000 entspricht 3000 millisekunden = 3 Sekunden fuer eine * Drehung */ Alpha rotationalpha = new Alpha(-1, 3000); /* 3. Erzeugung des RotationInterpolator-Objektes */ RotationInterpolator rotator = new RotationInterpolator(rotationAlpha, objspin); /** * Ein BoundingSphere definiert ein Gebiet (Kugel), in dem * ein Verhalten aktiv ist. Standardausrichtung ist der Ursprung * mit einem Radius von 1. */ BoundingSphere bounds = new BoundingSphere(); rotator.setschedulingbounds(bounds); objspin.addchild(rotator); objroot.addchild(objspin); return objroot; Anlage A3) /** * Programm: Zylinder.java * * Erzeugung zweier Zylinder (grün und rot), die unterschiedliche Anzahl * an Unterteilung der X-Dimension besitzen. * Markus Falkner 1.0 */ import java.awt.borderlayout; import java.awt.event.*; import java.awt.graphicsconfiguration; import javax.media.j3d.*; import javax.vecmath.*; import javax.swing.jframe; import com.sun.j3d.utils.universe.*; import com.sun.j3d.utils.geometry.cylinder; Seite 32

33 public class Zylinder extends JFrame public static void main(string[] args) Zylinder zylinder = new Zylinder(); /* WindowListener hinzufuegen */ zylinder.addwindowlistener(new WindowAdapter() public void windowclosing(windowevent e) /* Beim Schliessen des Fenster, Programm beenden */ System.exit(0); ; ); public Zylinder() /* Universum festlegen */ GraphicsConfiguration config = SimpleUniverse.getPreferredConfiguration(); Canvas3D canvas3d = new Canvas3D(config); /* Canvas3D Objekt zum Frame hinzufuegen */ this.getcontentpane().add(canvas3d,new BorderLayout().CENTER); /* Erzeugung eines SimpleUnviverse-Objektes */ SimpleUniverse universum = new SimpleUniverse(canvas3D); /** Anpassung des SimpleUniverse-Objektes: * setnominalviewingtransform() bewirkt, das der Augpunkt * auf (x,y,z) = (0,0,2.41) festgelegt wird (Siehe Java3D API) * getviewingplatform gibt die ViewingPlatfrom zurueck. * Man schaut also in negativer z-richtung. **/ universum.getviewingplatform().setnominalviewingtransform(); /* Erzeugung des Content Branch-Graphen */ BranchGroup scene = createscenegraph(); /* Content Branch-Graphen kompilieren */ scene.compile(); /* Content Branch-Graph dem SimpleUniverse-Objekt hinzufuegen */ universum.addbranchgraph(scene); /* Titel des JFrames setzen */ this.settitle("zylinder"); /* Groesse des JFrames setzen */ this.setsize(300,300); /* Frame anzeigen */ this.show(); private Appearance myappearance() //Appearence - Objekt erzeugen Appearance appearance = new Appearance(); //Attribut-Objekt erzeugen PolygonAttributes polyattrib = new PolygonAttributes(); TransparencyAttributes transparenz2 = new TransparencyAttributes(TransparencyAttributes.NICEST, 0.5f); // Farbobjekt erzeugen mit Farbe grün Color3f mycolor3f = new Color3f(1.0f, 0.0f, 0.0f); // Shader festlegen ColoringAttributes colorattrib = new ColoringAttributes(myColor3f, ColoringAttributes.NICEST); Seite 33

34 //Attribut-Objekt mit set-methoden belegeb (hier Polygonmodell ist nur mit Linien) // mit *.POLYGON_FILL würde es gefüllt werden polyattrib.setpolygonmode(polygonattributes.polygon_line); appearance.setpolygonattributes(polyattrib); appearance.settransparencyattributes(transparenz2); appearance.setcoloringattributes(colorattrib); return appearance; private Appearance myappearance2() //Appearence - Objekt erzeugen Appearance appearance = new Appearance(); //Attribut-Objekt erzeugen PolygonAttributes polyattrib = new PolygonAttributes(); TransparencyAttributes transparenz1 = new TransparencyAttributes(TransparencyAttributes.NICEST, 0.5f); // Farbobjekt erzeugen mit Farbe grün Color3f mycolor3f = new Color3f(0.0f, 1.0f, 0.0f); // Shader festlegen ColoringAttributes colorattrib = new ColoringAttributes(myColor3f, ColoringAttributes.NICEST); //Attribut-Objekt mit set-methoden belegeb (hier Polygonmodell ist nur mit Linien) // mit *.POLYGON_FILL würde es gefüllt werden polyattrib.setpolygonmode(polygonattributes.polygon_line); appearance.setpolygonattributes(polyattrib); appearance.settransparencyattributes(transparenz1); appearance.setcoloringattributes(colorattrib); return appearance; private BranchGroup createscenegraph() /* Wurzel des Content Branch-Graphen erzeugen */ BranchGroup objroot = new BranchGroup(); Transform3D t3d = new Transform3D(); TransformGroup objspin = null; /************************************* 1. Objekt ********************/ /* Objekt verschieben um 0.6 in negative X-Richtung, 0.6 nach hinten*/ t3d.settranslation(new Vector3f(-0.6f, 0.0f, -0.6f)); objspin = new TransformGroup(t3d); /* Zylinder 1 erzeugen mit 6 Pkt in der X-Dimension */ Cylinder myobj = new Cylinder(0.4f,0.9f,Cylinder.GEOMETRY_NOT_SHARED, 6,5, myappearance()); objspin.addchild(myobj); objroot.addchild(objspin); /************************************* 2. Objekt ******************/ /* Objekt verschieben um 0.6 in positive X-Richtung, 0.6 nach hinten*/ t3d.settranslation(new Vector3f(0.6f, 0.0f, -0.6f)); objspin = new TransformGroup(t3d); /* Zylinder 2 erzeugen mit 50 Pkt in der X-Dimension */ Cylinder myobj2 = new Cylinder(0.4f,0.9f,Cylinder.GEOMETRY_NOT_SHARED, 50,5, myappearance2()); objspin.addchild(myobj2); objroot.addchild(objspin); return objroot; Seite 34