Dokumentation_CarinaFleck

JAVA 3D – Licht und Material
Carina Fleck
Inhaltsverzeichnis
1
2
Einordnung in die Objekthierarchie ...................................................................2
Lighting Model .....................................................................................................2
2.1
Vektoren des Lighting Model .......................................................................... 3
2.1.1
2.1.2
2.2
3
4
Reflexionstypen .............................................................................................. 6
Shading Model .....................................................................................................6
Licht ......................................................................................................................7
4.1
Eigenschaften von Lichtquellen ...................................................................... 8
4.2
Die Licht-Klassen ............................................................................................ 8
4.2.1
4.2.2
4.2.3
4.2.4
4.2.5
4.3
5
6
7
8
Render-Zeit Optimierung .......................................................................... 3
Oberflächen-Normale ............................................................................... 4
Ambientes Licht (AmbientLight) ................................................................ 8
Gerichtetes Licht (DirectionalLight) ........................................................... 9
Punktlichtquelle (PointLight) ....................................................................10
Spot (SpotLight) .......................................................................................12
Vergleich der Licht-Typen ........................................................................14
Grobe Regeln zum Einsatz von Licht.............................................................14
Material: ..............................................................................................................15
5.1
Die Appearance-Klasse .................................................................................15
5.2
Material-Komponenten: .................................................................................15
Farbmodell und seine Auswirkung ..................................................................17
Einflussbereich von Licht (region of influence) ..............................................18
7.1
BoundingLeaf ................................................................................................18
7.2
Scoping of Light .............................................................................................19
Schatten .............................................................................................................19
8.1
Schatten Polygone.........................................................................................19
8.2
Schatten Texturen .........................................................................................20
8.3
Probleme bei der Schatten-Generierung .......................................................20
9 Anmerkungen ....................................................................................................20
10 Literaturverzeichnis ..........................................................................................21
Seite 1 von 21
JAVA 3D – Licht und Material
Carina Fleck
1 Einordnung in die Objekthierarchie
Die verwendeten Klassen für die Lichterzeugung sind Unterklassen der abstrakten
Oberklasse „Light“.
Die Licht-Klassen gehören zur Klasse „Node“, während die Material-Klasse zur
„NodeComponent“-Klasse gehört.
2 Lighting Model
Java 3D versucht mit Hilfe des Beleuchtungsmodells (Lighting Model) die
Gegebenheiten der realen Welt nachzubilden.
Um dies zu erreichen, werden für jedes Vertex eines visuellen Objekts 3 Vektoren
festgelegt, die zusammen mit der Materialbeschaffenheit und den charakteristischen
Eigenschaften des Lichts die Berechnung der Farbschattierung ermöglichen.
Seite 2 von 21
JAVA 3D – Licht und Material
Carina Fleck
2.1
Vektoren des Lighting Model
Das Lighting-Modell unterscheidet den Normalen-Vektor (N), der senkrecht auf der
der Oberfläche steht, die Lichtrichtung (L) und die Benutzerblickrichtung (E).
Anhand des Normalen-Vektors und der Lichtrichtung kann der Einfallswinkel des
Lichts berechnet werden und mit Hilfe des Benutzerblickrichtung die Sichtbarkeit für
den Nutzer. Aus dieser Berechnung entsteht dann die Schattierung (Shade) des
betreffenden Vertex.
2.1.1 Render-Zeit Optimierung
Da die Schattierung der sichtbaren Objekte einen bedeutenden Teil der Render-Zeit
einnimmt, ist es sinnvoll, die Lichtrichtungs-Vektoren (L) und die BenutzersichtVektoren (E) konstant zu halten.
Der Lichtrichtungs-Vektor ist bei "Gerichtetem Licht“ (Directional Light) konstant.
Vergleich der Licht-Vektoren von Gerichtetem Licht und Punktlicht.
Der Benutzersicht-Vektor ist standardmäßig auf "Infinite Eye“ gesetzt. Das bedeutet,
dass man annimmt, der Benutzer betrachte die Szene von einer unendlich entfernten
Position aus. Geht die Position des Benutzer ins unendliche, streben die
Benutzerblickrichtungs-Vektoren (Viewer´s Eye) einen zu einander parallelen Verlauf
an, was die Rechenzeit erheblich einschränkt. Allerdings wird dadurch die Realität
nicht genau abgebildet.
Seite 3 von 21
JAVA 3D – Licht und Material
Carina Fleck
Die korrekte Abbildung der Benutzerblickrichtung (Viewer´s Eye) ist “Locale Eye“.
Folgendes Beispiel zeigt aber, dass sich die Unterschiede zwischen den beiden
Perspektiven nur auf die Position der Glanzpunkte auswirkt.
Infinite Eye
Locale Eye
Methoden zum Setzen der Betrachter-Perspektive:
void setLocalEyeLightingEnable(boolean flag)
Setzt ein Flag, welches Aufschluss darüber gibt, ob "Locale Eye“ gesetzt wird.
Beispiel:
SimpleUniverse su = new SimpleUniverse(canvas);
su.getViewer().getView().setLocalEyeLightingEnable(true);
2.1.2 Oberflächen-Normale
Oberflächen-Normalen (Surface Normals) werden für das Beleuchtungs-Modell von
Java 3D benötigt.
Für die Primitiven wie Box, Sphere etc. werden diese Normalen automatisch erzeugt.
Die Normale eines Vertex von einem Objekt, dass mit Hilfe der Geometry-Klasse
erstellt wurde, muss mit Hilfe der setNormal()-Funktion gesetzt werden.
Oder man erstellt sein Objekt mit Hilfe der GeometryInfo Klasse, welche direkt von
der Klasse java.lang.Object abgeleitet ist. Diese kann den NormalGenerator
verwenden, welcher ebenfalls von der Klasse java.lang.Object abgeleitet ist und die
Normalen für das entsprechende Objekt generiert.
Da für jedes Vertex nur 1 Normale erzeugt wird, kann es zu Problemen kommen,
wenn beide Seiten eines Polygons zu sehen sind. Da die Normale nur für eine der
beiden Seiten richtig ist, wird die Rückseite nur mit indirekter (ambienter)
Schattierung gerendert, da die anderen Beleuchtungen eine gültige OberflächenNormale voraussetzen.
Seite 4 von 21
JAVA 3D – Licht und Material
Carina Fleck
Dieses Problem wird in Java 3D mit Hilfe einer zweiten Normalen gelöst, die in die
entgegengesetzte
Richtung
zeigt.
Sie
wird
mit
der
Funktion
setBackFaceNormalFlip() erzeugt.
Nun werden sowohl Vorder- als auch Rückseite mit den entsprechenden Lichttypen
gerendert.
Ein weiteres Problem mit den Oberflächen-Normalen ergibt sich, wenn innerhalb
eines Vertex die Richtung der Oberflächen zu stark voneinander abweicht. Stehen
die Oberflächen z.B. in einem 90° Winkel aufeinander, ist die Normale der einen
Oberfläche parallel mit der nächsten Oberfläche.
Seite 5 von 21
JAVA 3D – Licht und Material
Carina Fleck
Setzt man die Normalen wie auf dem nächsten Bild, werden die Oberflächen
konstant schattiert. Auch bei einem Würfel hat man das Problem, das die
Oberflächen senkrecht aufeinander stehen.
Zur Lösung dieses Problems wird die Anzahl der Vertices erhöht, was die
Spezifikation von mehr Normalen mit sich bringt. Allerdings steigt dann auch die
Renderzeit.
2.2
Reflexionstypen
Das Lighting-Modell von Java 3D unterstützt 3 Arten der Reflektion. Die ambiente
Reflektion, die ungerichtetes, relativ schwaches Licht reflektiert. Die diffuse
Reflektion, die sowohl ungerichtetes als auch gerichtetes Licht reflektiert. Sie wird als
die "normale“ Reflektion des Lichts wahrgenommen. Und die Glanzlicht-Reflektion
(Specular Reflection), die bei einem bestimmten Einfallswinkel des Lichts auftritt.
Wie auf dem obigen Bild zu sehen ist, werden weder Schatten noch Lichteffekte
zwischen den Objekten, wie Reflektionen etc., von Java 3D realisiert, da diese sehr
komplexe Berechnungen erforderten. Es müssten für die Berechnungen alle Objekte
und deren Beziehungen in der Szene berücksichtigt werden. Werden dennoch
Schatten oder andere Lichteffekte benötigt, müssen diese nachträglich in die Szene
eingefügt werden. Unter Punkt 8 wird noch näher auf die Generierung von Schatten
eingegangen.
3 Shading Model
Bei der Schattierung in Java 3D kommt standardmäßig entweder Flat Shading,
welches auch als Konstante Schattierung bezeichnet wird, oder Gouraud Shading
zum Einsatz. Andere Shading Modelle, wie z.B. Phong- und Blinn-Shading, sind mit
wesentlich mehr Rechenzeit verbunden und eignen sich deshalb noch nicht für den
Einsatz in Echtzeit.
Seite 6 von 21
JAVA 3D – Licht und Material
Carina Fleck
Beim Flat Shading wird allen Pixel eines Polygons die berechnete Schattierung des
Vertex zugewiesen. Das Objekt wirkt daher oft kantig. Besonders auffällig wird
dieses eckige Erscheinungsbild bei runden Flächen.
Gouraud Shading hingegen interpoliert die Schattierungen von den Ecken des
Polygons ausgehend. Somit werden keine Kanten mehr sichtbar. Allerdings kann es
beim Gouraud Shading passieren, dass Highlights übersprungen werden.
Sphere mit Flat Shading
Sphere mit Gouraud Shading
4 Licht
Der Bereich einer Szene, in dem Objekte von einer Lichtquelle beleuchtet werden,
wird als "region of influence“ des Licht-Objekts bezeichnet. Der einfachste Weg, den
Einflussbereich eines Licht-Objekts zu setzen, ist über Nutzung des Bounds-Objekts
und die setInfluencingBounds() Methode des Lichts.
Um Beleuchtung in einer Szene zu nutzen, müssen folgende Schritte ausgeführt
werden:

1. Licht wählen:
o Einflussbereich der Lichtquelle festlegen durch begrenzendes Objekt:
set bounds
o Licht zum Szenengraph hinzufügen:

2. Spezifikation der visuellen Objekte:
o Normale der Oberfläche berechnen (Vorsicht bei Vorder-/Rückseite):
o Materialeigenschaften zuweisen
Ein einfaches Beispiel:
1.
2.
3.
4.
5.
6.
7.
8.
9.
Appearance createAppearance() {
Appearance appear = new Appearance();
//Material-Objekt instanziieren
Material material = new Material();
//Material-Eigenschaften der Appearance-Klasse zuweisen
appear.setMaterial(material);
Seite 7 von 21
JAVA 3D – Licht und Material
Carina Fleck
10. return appear;
11. }
12.
13. BranchGroup createScene (){
14. BranchGroup scene = new BranchGroup();
15.
16. //Normale wird bei Primitiven automatisch gesetzt
17. scene.addChild(new Sphere(0.5f, Sphere.GENERATE_NORMALS,
18. createAppearance()));
19.
20. //Ambiente Lichtquelle instanziieren
21. AmbientLight lightA = new AmbientLight();
22.
23. //Einflußbereich des Lichts setzen
24. lightA.setInfluencingBounds(new BoundingSphere());
25.
26. //Licht zum Szenengraph hinzufügen
27. scene.addChild(lightA);
28.
29. return scene;
30. }
(siehe Java 3DTM API Tutorial)
4.1
Eigenschaften von Lichtquellen
Alle Lichtarten werden von der abstrakten Oberklasse
Grundsätzliche Eigenschaften von Lichtquellen sind:

Der Ein/Aus Status einer Lichtquelle:
void setEnable(boolean state);
//Default: TRUE

Die Farbe des Lichts:
void setColor(Color3f color);

abgeleitet.
//Default: white(1,1,1)
Die Einflussregion des Lichts:
void setInfluencingBounds(Bounds bounds)
4.2
"Light“
//Default: null
Die Licht-Klassen
4.2.1 Ambientes Licht (AmbientLight)
Unter Ambientem Licht versteht man die indirekte Beleuchtung der visuellen Objekte.
Es simuliert das durch Reflektion entstehende Umgebungslicht und ist für eine
naturgetreue Abbildung der Realität notwendig.
Seite 8 von 21
JAVA 3D – Licht und Material
Carina Fleck
Die Vektoren Lichtrichtung, Normale und Benutzerblickrichtung werden nicht
berücksichtigt, was das Fehlen der diffusen und spekulären Reflektion zur Folge hat.
Die Geometrie der visuellen Objekte hat keinen Einfluss.
Ambientes Licht hat weder eine Richtung noch eine Position, daher hat es an allen
Stellen der visuellen Objekte die gleiche Intensität und es kommt zu keiner
Abschwächung des Lichts.
Der Einflussbereich des Ambienten Lichts muss dennoch festgelegt werden
(Bounds).
4.2.1.1 Funktionen
Konstruktoren:
AmbientLight()
Konstruktor, der die Default-Wert für Color und den Enable-Status festlegt
AmbientLight(Color3f color)
AmbientLight(boolean lightOn, Color3f color)
4.2.2 Gerichtetes Licht (DirectionalLight)
Gerichtetes Licht kann mit Sonnenlicht verglichen werden. Es wirkt wie eine sehr weit
entfernte Lichtquelle.
Gerichtetes Licht besitzt nur einen konstanten Lichtrichtungsvektor(L), demzufolge ist
die Lichtrichtung an allen Stellen der Objekte gleich.
Seite 9 von 21
JAVA 3D – Licht und Material
Carina Fleck
.
Da das Licht keinen Ursprung hat, kommt es zu keiner Abschwächung des Lichtes.
Es wird nur die diffuse und die Glanzlicht (specular) - Reflektion genutzt, somit hat
die Geometrie der visuellen Objekte Einfluss auf die Schattierung.
4.2.2.1 Funktionen
Konstruktoren:
DirectionalLight()
Konstruktor, der die Default-Wert für Color, Enable-Status und Direction
(direction: (0, 0, -1)) festlegt.
DirectionalLight(Color3f color, Vector3f direction)
DirectionalLight(boolean lightOn, Color3f color, Vector3f direction)
Methoden:
void setDirection(Vector3f direction)
setzt die Lichtrichtung
void setDirection(float x, float y, float z)
setzt die Lichtrichtung
4.2.3 Punktlichtquelle (PointLight)
Punktlicht strahlt in alle Richtungen, deswegen kommt es meistens bei der
Simulation von Glühbirnen oder Kerzenlichtern zum Einsatz. Es täuscht eine
Lichtquelle ohne Linsen oder Reflektoren vor.
Im Gegensatz zum Gerichteten Licht besitzt das Punktlicht ein Position. Daher sind
die Lichtrichtungsvektoren nicht konstant, was einen höheren Rechenaufwand
bedeutet.
Seite 10 von 21
JAVA 3D – Licht und Material
Carina Fleck
Aufgrund des vorhandenen Ursprungs von Punktlicht, nimmt die Intensität mit der
Entfernung ab. Diese Abschwächung (Attenuation) wird nach folgender Formel
berechnet:
attenuatio n 
1
constant  linear * distance  quadratic * distance 2
Folgendes Beispiel zeigt die Auswirkung des Abschwächungsfaktors
Bild&Graphik-4-IV.pdf der Universität Augsburg (Literaturverzeichnis)
Punktlicht wird wie das Gerichtete Licht nur für die diffuse und die Glanzlicht
(specular) - Reflektion genutzt. Somit hat auch die Geometrie Einfluss auf die
Schattierung.
Ein Bewegen des Punktlichtes führt zu Veränderungen in der Schattierung.
4.2.3.1 Funktionen
Konstruktoren:
PointLight()
Konstruktor, der die Default-Wert für Color, Enable-Status, Position (0,0,0) und
Attenuation (1,0,0) festlegt.
PointLight(Color3f color, Point3f position, Point3f attenuation)
PointLight(boolean lightOn, Color3f color, Point3f position, Point3f
attenuation)
Seite 11 von 21
JAVA 3D – Licht und Material
Carina Fleck
Methoden:
void setAttenuation(Point3f attenuation)
Setzt die aktuellen Attenuation-Werte und platziert sie in dem spezifizierten
Parameter. Die Werte, die in dem Point3f – Objekt spezifiziert werden, sind die
Werte für constant, linear und quadratic.
attenuatio n 
1
constant  linear * distance  quadratic * distance 2
Der distance-Wert wird aus der Entfernung der Lichtquelle zu dem Vertex, das
schattiert werden soll, ermittelt.
void setAttenuation(float constant, float linear, float quadratic)
siehe oben.
void setPosition(Point3f position)
Setzt die Position des Lichts.
void setPosition(float x, float y, float z)
Setzt die Position des Lichts.
4.2.4 Spot (SpotLight)
SpotLight ist eine Unterklasse von Punktlicht. Es scheint in ein bestimmte Richtung
und wird zur Simulation von Lichtquellen mit Linsen und Reflektoren genutzt, wie z.B.
bestimmte Lampen, Taschenlampen u.s.w..
Wie Punktlicht besitzt SpotLight eine Position, so das es ebenfalls zu
Abschwächungen (attenuation) kommt. Die Abschwächung folgt der gleichen Formel
wie oben erwähnt.
Seite 12 von 21
JAVA 3D – Licht und Material
Carina Fleck
Zusätzlich besitz SpotLight eine Richtung, einen Öffnungswinkel (spread angle) und
eine Konzentration. Die Konzentration legt fest, wie stark das Licht vom Zentrum des
Öffnungswinkels zu den Seiten hin abschwächt.
Somit wird die Lichtintensität an einem Vertex sowohl durch die Entfernung, als auch
durch den Winkel, den das Vertex zum Richtungsvektor einnimmt, bestimmt.
Ein kleines Beispiel, wie sich die Variation von Öffnungswinkel und Konzentration
auswirkt.
Bild&Graphik-4-IV.pdf der Universität Augsburg (Literaturverzeichnis)
Durch den Öffnungswinkel ist SpotLight das einzige Licht, das nur einen Teil eines
Objekts beleuchten kann.
SpotLight ist wie Punktlicht und Gerichtete Licht nur für die diffuse und die Glanzlicht
(specular) - Reflektion verantwortlich. Somit hat auch die Geometrie Einfluss auf die
Schattierung.
Die Bewegung des SpotLight und das Ändern der Ausrichtung (Richtung,
Öffnungswinkel, Konzentration) führt zu Veränderungen in der Schattierung.
4.2.4.1 Funktionen
Konstruktoren:
SpotLight()
Konstruktor, der die folgenden Default-Wert initialisiert:
lightOn true
color (1, 1, 1)
position (0, 0, 0)
Seite 13 von 21
JAVA 3D – Licht und Material
Carina Fleck
attenuation (1, 0, 0)
direction (0, 0, -1)
spreadAngle PI (180 degrees)
concentration 0.0
SpotLight(Color3f color, Point3f position, Point3f attenuation, Vector3f
direction, float spreadAngle, float concentration)
SpotLight(boolean lightOn, Color3f color, Point3f position, Point3f
attenuation, Vector3f direction, float spreadAngle, float concentration)
Methoden:
Zusätzlich zu den Methoden vom Punktlicht werden folgende Methoden
bereitgestellt.
void setConcentration(float concentration)
Setzt die Konzentration von SpotLight.
void setDirection(float x, float y, float z)
Setzt die Lichtrichtung.
void setDirection(Vector3f direction)
Setzt die Lichtrichtung.
void setSpreadAngle(float spreadAngle)
Setzt den Öffnungswinkel von SpotLight.
4.2.5 Vergleich der Licht-Typen
Bis auf das Ambiente Licht benötigen alle Lichtsorten für die Berechnung
Normalenvektoren. Da das Ambiente Licht somit weder abschwächt, noch die
Geometrie der Objekte berücksichtigen muss, verbraucht es die wenigste
Rechenleistung.
Das Gerichtete Licht hat einen konstanten Lichtrichtungsvektor, da es keine Position
besitzt. Es ist daher nach dem Ambienten Licht mit der kürzesten Rechenzeit
verbunden.
Bei dem Punktlicht variieren die Lichtrichtungsvektoren, demzufolge schwächt es ab
und verändert die Schattierung der visuellen Objekte, wenn es bewegt wird. Seine
Renderzeit ist wesentlich höher als die des Gerichteten Lichts.
Das SpotLight benötigt die größte Rechenzeit, da es zusätzlich zu Position und
Abschwächung noch eine Richtung, einen Öffnungswinkel und eine Konzentration
besitzt.
Ambientes Licht < Gerichtetes Licht < Punktlicht < Spotlight
4.3
Grobe Regeln zum Einsatz von Licht
Seite 14 von 21
JAVA 3D – Licht und Material
Carina Fleck
Generell ist zu sagen, dass man so wenig Lichtquellen wie möglich einsetzt, um die
Rechenzeit zu verkürzen. Auch sollte man Ambientes und Gerichtetes Licht
bevorzugen, wie oberhalb erwähnt wurde.
Es gibt nur ein paar allgemeine Regeln zum Einsatz von Lichtquellen, letztlich hängt
es von dem gewünschten visuellen Effekt ab, wie und wie viele Lichtquellen man
einsetzt.
Meist genügt es nur 2 Lichtquellen in einer Szene zu haben. Ein Hauptlichtquelle und
eine Lichtquelle, die die nicht beleuchteten Stellen der Objekte auffüllt.
Auch wird meist eine Ambiente Lichtquelle mit sehr großem Einflussbereich gewählt,
um die Objektstellen ohne diffuse und Glanzlicht (specular) – Reflektion zu
beleuchten.
Allerdings darf auf ein bestimmtes Objekt maximal der Einflussbereich von 8
verschiedenen Lichtquellen fallen (ansonsten ist die Anzahl der Lichtquellen nicht
begrenzt). Diese Einschränkung beruht auf der OpenGL – Spezifiktation, die maximal
8 Lichtquellen erlaubt und Grundlage von Java 3D ist.
5 Material:
Die Klasse Material spezifiziert die Materialeigenschaften eines visuellen Objekts,
wenn das Objekt beleuchtet ist.
5.1
Die Appearance-Klasse
Die Appearence-Klasse ist genau wie die Material-Klasse von der Klasse
NodeComponent abgeleitet. Sie erhält eine Referenz auf das Material-Objekt und
wird ebenfalls als Referenz an das Shape-Objekt übergeben:
5.2
Material-Komponenten:
Ambiente Farbe(Ambient Color):
Die Ambiente Farbe setzt die Farbe des visuellen Objekts in den Bereichen, die nur
von Ambientem Licht getroffen werden.
void setAmbientColor(Color3f color)
void setAmbientColor(float r, float g, float b)
Seite 15 von 21
JAVA 3D – Licht und Material
Carina Fleck
Diffuse Farbe ( Diffuse Color) :
Legt die Farbe der diffusen Reflektion fest. Die Diffuse Farbe kann auch als "Grund“
– Farbe des visuellen Objekts angesehen werden.
void setDiffuseColor(Color3f color)
void setDiffuseColor(float r, float g, float b)
void setDiffuseColor(float r, float g, float b, float a) //Diffuse Color und alpha
Spekuläre Farbe( Specular Color):
Die Spekuläre Farbe beschreibt die Farbe der Glanzpunkte (Specular Reflection).
void setSpecularColor(Color3f color)
void setSpecularColor(float r, float g, float b)
Emittierte Farbe( Emissive Color):
Unter Emittierter Farbe versteht man die Farbe, die von einem Objekt selber
ausgestraht wird.
Emittierte Farbe kann für den “Glow in the dark” – Effekt eingesetzt werden. Objekte
mit dieser Farbe können aber nicht als Lichtquellen angesehen werden, da sie keine
Wirkung auf andere Objekte haben.
void setEmissiveColor(Color3f color)
void setEmissiveColor(float r, float g, float b)
Glanz-Faktor (Shineness) :
Mit dem Glanz-Faktor wird der Wert für die Berechnung der Glanzpunkte festgelegt.
Je kleiner der Wert ist, desto größer ist die Ausdehnung des Glanzpunktes (Specular
Reflektion).
void setShininess(float shininess)
Ein-/Aus-Status der Beleuchtung:
Setzt die Beleuchtung des Objektes, welches das entsprechende Appearence-Objekt
enthält, auf ein oder aus.
Seite 16 von 21
JAVA 3D – Licht und Material
Carina Fleck
void setLightingEnable(boolean state)
6 Farbmodell und seine Auswirkung
Das Farbmodell in Java 3D orientiert sich im Gegensatz zum Lighting-Model nicht an
den physikalischen Gegebenheiten der Natur. Es wird das RGB-Farbmodell
verwendet, welches ein additives Farbmodell ist.
Daher ergibt z.B. rotes und blaues Licht gemischt keine violette Farbe, sondern
Magenta.
Die Nutzung dieses Farbmodells führt zu dem Effekt, das farbige Objekte, die mit
einfarbigem Licht beleuchtet werden, nur sichtbar sind, wenn ihre Farbe Anteile der
Farbe des Lichts enthält.
weißes Licht
blaues Licht
rotes Licht
grünes Licht
magentafarbenes Licht (1,0,1)
Ein weiteres Beispiel:
weißes Licht
blaues Licht
In der Realität besteht Licht nicht nur aus 3 Farbanteilen, sondern aus einer
Kombination von vielen verschiedenen Wellenlängen.
Seite 17 von 21
JAVA 3D – Licht und Material
Carina Fleck
In Java 3D gibt es 3 Wege, die Farbe eines visuellen Objektes zu setzen. Zum einen
die ColoringAttributes die einer Appearance-Klasse zugeordnet werden. Dann die
Farben der Material-Klasse, und die "per-vertex color“ von Geometry-Objekten.
Es gib zwei Regeln, wie die Farben berücksichtigt werden, wenn mehr als eine Farbe
gesetzt wurde:


Die Material-Farbe wird gerendert, wenn das visuelle Objekt beleuchtet ist,
ansonsten wird die ColoringAttributes-Farbe beachtet.
Ist eine "per-vertex color“ für ein Objekt gesetzt, wird sie berücksichtigt,
unabhängig ob eine der beiden anderen Farben gesetzt wurde.
7 Einflussbereich von Licht (region of influence)
In Java 3D ist der Einfluss von Licht-Objekten zwar unabhängig von ihrer Position im
Szenengraph, was aber nicht für die Bounds-Objekte gilt. Wird nun die
Einflussbeschränkung (influencing bounds) des Lichts über die Referenzierung eines
Bounds-Objekts geregelt, führt dies zu einer Verbindung der Position des Lichts mit
den Einflussbeschränkung (influencing bounds).
Auch kann es vorkommen, das zwei Licht-Objekte, die auf das selbe Bounds-Objekt
zugreifen, dennoch verschiedene influencing bounds besitzen.
(Siehe Java 3DTM API Tutorial – 6.2.2)
7.1
BoundingLeaf
Um nun die Beziehung zwischen der Licht-Objekt Position und der
Einflussbeschränkung (influencing bounds) möglichst variabel zu halten, bietet sich
die Nutzung der Klasse BoundingLeaf an. Diese ist eine Unterklasse von der Klasse
Node, was auch auf die Lichtklassen zutrifft.
Die BoundingLeaf-Objekte werden dem Szenengraph hinzugefügt, daher sind Sie
unabhängig vom Licht.
Mit Hilfe der Funktion setInfluencingBoundingLeaf(BoundingLeaf
region) wird das BoundingLeaf-Objekt als Einflussbeschränkung (influencing
bounds) des Licht-Objektes spezifiziert. Diese Spezifikation überschreibt alle
bisherigen localen influencing bounds.
Ein BoundingLeaf-Objekt kann von vielen Licht-Objekten genutzt werden. Anders als
bei der Referenzierung eines Bounds-Objekts haben dann alle Licht-Objekte, die auf
das eine BoundingLeaf-Objekt zugreifen, immer den selben Einflussbereich.
Seite 18 von 21
JAVA 3D – Licht und Material
Carina Fleck
7.2
Scoping of Light
Mit Hilfe von Scoping wird der Einflussbereich des Lichts begrenzt. Scoping erlaubt
die Begrenzung des Einflussbereiches eines Licht-Objekts auf einen gewissen Teil
des Szenengraphen.
Auch kann der Einflussbereich des Lichts auf ein visuelles Objekt zurückgeführt
werden, welches sich unterhalb der Group-Spezifikation befindet.
Methoden des Licht-Objekts zum Scoping:
void addScope(Group scope)
Fügt die spezifizierten Gültigkeitsbereich (scope) in die Knotenliste von scopes
ein.
java.util.Enumeration getAllScopes()
Gibt das Enumeration object von allen scopes zurück.
void insertScope(Group scope, int index)
Fügt den Gültigkeitsbereich (scope), der durch den Group-Knoten spezifiziert
wird, an dem spezifizierten Index ein.
int numScopes()
Gibt die Anzahl der Gültigkeitsbereiche des entsprechenden Lichts zurück.
void removeScope(int index)
Removes the node's scope at the specified index location.
8 Schatten
Wie schon erwähnt, unterstützt das Lighting-Modell weder Schatten noch sonstige
Lichteffekte zwischen verschiedenen Objekten, weil für die richtige Berechnung von
Schatten jedes visuelle Objekt und dessen Einfluss auf die anderen Objekte der
Szene berücksichtigt werden müsste. Hinzu kommt noch, dass die Richtung der
Lichtquellen in der Realität nicht 100%-ig einheitlich ist und die Lichtquellen auch
keine perfekte Position besitzen. Dies für zu unscharfen Rändern der Schatten.
Im folgenden werden zwei verschiedene Methoden gezeigt, die einen Schatten mehr
oder weniger gut simulieren.
8.1
Schatten Polygone
Polygone, die als Schatten eines Objekts verwendet werden und deren Farbe über
die ColoringAttributes oder die per-vertex Geometry color festgelegt wird, werden als
farbige Schatten-Polygone (colored shadow polygon) bezeichnet. Diese Art Schatten
zu simulieren sieht jedoch oft unecht aus.
Eine andere Möglichkeit besteht darin, die Farbe der Polygone über die
Materialeigenschaften festzulegen. Solch ein Polygon nennt man schattiertes
Schatten-Polygon. Die Schattierung dieses Polygons ist abhängig von den LichtSeite 19 von 21
JAVA 3D – Licht und Material
Carina Fleck
Objekten, die auch den Schatten beeinflussen würden. Ein schattiertes SchattenPolygon sieht meistens echter aus, ist aber auch wesentlich schwerer festzulegen.
Es ist auch möglich, den Einflussbereich des Lichts dahingehend zu beschränken,
dass Bereiche (Polygone) nicht beleuchtet werden, die im Schatten eines anderen
Objekts stehen. Dies ist mittels Scoping möglich. Allerdings ist es nicht einfach zu
berechnen, welcher Bereich eines Objektes im Schatten liegt und welcher nicht.
8.2
Schatten Texturen
Man kann Schatten über das Einfügen von Texturen erzeugen. Dies geschieht
entweder über das Texturieren von Schatten-Polygonen, oder durch Aufbringen der
Textur auf das visuelle Objekt.
8.3
Probleme bei der Schatten-Generierung
Hier nun einige Anforderungen, die eine realistische Schatten-Generierung erfüllen
müsste:

Für den Schatten müssten alle Lichtquellen und Effekte zwischen Objekten
berücksichtigt werden, die das Objekt, dass einen Schatten erhalten soll,
betreffen.

Die Schattengenerierung muss die Dimensionen und die Geometrie der
Objekte berücksichtigen, auf die der Schatten projiziert wird.

Bei Bewegung des visuellen Objektes, muss der Schatten mitbewegt werden.

Auch ändert sich die Form des Schattens, wenn das betreffende Objekt sich
bewegt.

u.s.w
9 Anmerkungen
Die Bilder, die in dieser Dokumentation verwendet wurden, sind zum größten Teil
aus dem Java 3DTM API Tutorial übernommen worden. Auch aus anderen Quellen
(siehe Literaturverzeichnis) wurden Bilder eingesetzt.
Seite 20 von 21
JAVA 3D – Licht und Material
Carina Fleck
10 Literaturverzeichnis
Java 3DTM API Tutorial
Internetseiten:
http://webster.fhs-hagenberg.ac.at/staff/haller/mmp5_20012002/08java3d_1.pdf
http://www.mathematik.unimuenchen.de/~vrmlsem/old/1999wi/Vortraege/Farbmodelle/Farbmodelle.html
http://multimedia.informatik.uniaugsburg.de/lehre/ss02/MMVL/Folien/Bild&Graphik-4-IV.pdf
http://www.fh-wedel.de/~ko/Galerie/2000-WS-Seminar/Moeller/index.htm
Illumination and Shading:
http://escience.anu.edu.au/lecture/cg/Illumination/index.en.html
Illumination in Java3D:
http://escience.anu.edu.au/lecture/cg/IlluminationJ3D/index.en.html
Seite 21 von 21