(13) Licht und Materialien
Vorlesung
„Computergraphik I“
S. Müller
x
z
y
0
u
C A
y
x z
y
x z
-f (r,t)
-n (l,b)
(
1,1,1)
(-1,-1,-1)
y
x
z
Modell/Weltkoordinaten Kamerakoordinaten
View Frustum Kanonisches Volumen
p R T S T
V M
M M
p
MODELVIEW
PROJECTION M
M
L R PERSP
ORTHO
'= ⋅ ⋅
→⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅
Viewport: OpenGL
1 1
-1
x y
-1 b/2
h/2
-h/2
x y
-b/2
2 2
'
2 2
'
h p
h p
b p
b p
y y
x x
+
⋅
=
+
⋅
=
0 b
p'
x− 1
x
=
p p
x= 1
…
…
x y
0 b
h
( 1 )
2
'
z= 1 ⋅ p
z+
p
OpenGL Rendering Pipeline
p R T S T
V p
MODELVIEW
M
' = ⋅ ⋅ ⋅ ⋅ ⋅ ⋅
'
'' M M M p
p
PROJECTION
M
L R PERSP
ORTHO
= ⋅ ⋅
→⋅
Division durch homogene Koordinate
Kamera im Ursprung, Blickrichtung entlang der negativen z-Achse (Rechtssystem)
Linkssystem: z-Achse nicht-linear skaliert, kanonisches Volumen vor perspektivischer Division, hier wird geclippt.
Kanonisches Volumen
Bildschirm- bzw.
Fensterkoordinaten, z-Wert zwischen (0,1), Rasterisierung
Viewport-Transformation
Clipping
Clipping
Wo?
-n
-f
(l,t)
(r,b)
1
xy
z (w,w,w)
(-w,-w,-w)
2
xy
z (1,1,1)
(-1,-1,-1)
3
Problem mit Option 1
Ebenengleichungen der Clippingebenen nicht so einfach zu bestimmen, bzw. Tests komplexer
-n
-f
(l,t)
(r,b)
Option 3?
x y
z
(-1,-1,-1)
(1,1,1)
0 1
0 0
1 0
1 1 1
0
=
−
⇒
=
−
=
y z
y x
n AX
Bestimmung der Ebenengleichungen der Clipebenen:
0 1
0 1
0 1
0 1
0 1
0 1
= +
= +
= +
=
−
=
−
=
−
z y x z y
Ergebnis:
x
Sieht einfach aus, aber…
z
z
n f nf p
p ' = + −
Problem mit Option 3
Unstetigkeit in der z-Transformation:
pz
p'z
f n
f n
n+f z-Werte kleiner 0 werden auf z‘- Werte größer n+f „geflippt“, was Clipping schwierig macht.
The winner is…(in OpenGL)
Clipping in homogenen Koordinaten (Option 2)
Wie berechnet man da die Clippingebenen?
(
l,t, n)
(
l,b,n)
(
r,b, n) (
r,t, n)
⋅ ⋅ f
n t f n
l f , ,
⋅ ⋅ f
n t f n
r f , ,
⋅ ⋅ f
n b f n
r f , ,
+ −
= ⋅
n p
n f f p n
p p
w p p p
z z
y x
z y x
' ' '
Ursprüngliches Frustum Perspekt. Transformation
Clipebenen im homogenen Raum
( l , t , n , 1 )
( l , b , n , 1 )
( r , b , n , 1 )
( r , t , n , 1 )
⋅ ⋅ ⋅
n f n f f n t f n
l f , , ,
⋅ ⋅ ⋅
n f n f f n t f n
r f , , ,
⋅ ⋅ ⋅
n f n f f n b f n
r f , , ,
Beispiel Ebene 2:
0 .
; − =
= wt bzw y wt
y
1 2
Beispiel Ebene 1:
0 .
; − =
= wr bzw x wr
x
l=b=n= -1; r=t=f= 1
Ergebnis
Clipebenen
0 )
6
0 )
5
0 )
4
0 )
3
0 )
2
0 )
1
= +
= +
= +
=
−
=
−
=
−
w z
w y
w x
w z
w y
w x
(4D Raum hier etwas „vereinfacht“ dargestellt, da w nicht konstant…)
x y
z
(-w,-w,-w)
(w,w,w)
2
6 1
Begründung 1
(l,t,n)
(l,b,n)
(r,b,n) (r,t,n)
⋅ ⋅ f
n t f n l f , ,
⋅ ⋅ f
n t f n r f , ,
⋅ ⋅ f
n b f n
r f , , n
a b
1) Ausgangssituation: Viewing Frustum
−
= 0 0 l r a
−
−
⋅
−
⋅
=
n f
n t t f
n l l f
b
( )( )
( ) Div durch(r l)(nf n)
l r n t t f
l r n f a
b
n − −
−
⋅ −
−
−
−
=
×
= .
0
−
= t n n
0
Linkssystem (!):
2) Berechnung der Normalen
(l,t,n,1)
(l,b,n,1)
(r,b,n,1) (r,t,n,1)
⋅ ⋅ ⋅
n f n f f n t f n
l f , , ,
⋅ ⋅ ⋅
n f n f f n t f n
r f , , ,
⋅ ⋅ ⋅
n f n f f n b f n
r f , , ,
+ −
= ⋅
n p
n f f p n
p p
w p p p
z z
y x
z y x
' ' '
3) Perspektivische Projektion liefert:
Begründung 2
4) Transformation der Normalen
( )
+
−
fn f n
fn n
n
1 0 0
1 0
0 0
0 0
1 0
0 0
0 1
⋅ − 0 0 t n
−
= t 0 1 0
Transponierte Inverse der Projektionsmatrix
Richtungsvektor:
hom. Koord. 0
(l,t,n,1)
(l,b,n,1)
(r,b,n,1) (r,t,n,1)
⋅ ⋅ ⋅
n f n f f n t f n
l f , , ,
⋅ ⋅ ⋅
n f n f f n t f n
r f , , ,
⋅ ⋅ ⋅
n f n f f n b f n
r f , , ,
n
= 0 n AX
= 0
− wt
y
Beispiel: obere Ebene: ein Punkt X ist dann Teil der Ebene, wenn gilt:
0 0 1 0
1
=
−
−
t n
t l
w z y x
5) Bestimmung der Ebenengleichung
6) Nach der orthographischen Projektion (analog für andere Ebenen) (Vorsicht: 4D Raum hier etwas vereinfacht dargestellt…)
0 0 0 0 0 0
= +
= +
= +
=
−
=
−
=
−
w z
w y
w x
w z
w y
w x
x y
z
(-w,-w,-w)
(w,w,w)
Beispiel 1
Nach der perspektivischen Projektion (vor der perspektivischen Division) seien zwei Punkte A und B gegeben. Gesucht ist die geclippte Linie:
+ +
+
+ +
+
+ +
+
−
−
−
+
−
−
−
−
−
w z
w y
w x
w z
w y
w x
2 1 0 0
2 1 4 0
1) Clip-Test (Vorzeichentest) an den Clipebenen
−
⋅ +
=
2 1 0 0
2 1 4 0
2 1 0 0
λ X
⋅ +
=
0 0 4 0
2 1 0 0
λ w
z y x
2) Berechnung des Schnittpunkts Geradengleichung
AB A
X = + λ ⋅
2 1
0 2 4
0
=
=
−
=
−
λ λ
w y
In die Ebenengleichung
= 2 1 2 0
⇒
C
= 2 1 0 0 A
= 2 1 4 0 B
A B
C
Umsetzung mit Cohen- Sutherland Bereichscode (6 Bit)
OpenGL Rendering Pipeline
p R T S T
V p
MODELVIEW
M
' = ⋅ ⋅ ⋅ ⋅ ⋅ ⋅
'
'' M M M p
p
PROJECTION
M
L R PERSP
ORTHO
= ⋅ ⋅
→⋅
Division durch homogene Koordinate
Kamera im Ursprung, Blickrichtung entlang der negativen z-Achse (Rechtssystem)
Linkssystem: z-Achse nicht-linear skaliert, kanonisches Volumen vor perspektivischer Division, hier wird geclippt.
Kanonisches Volumen
Bildschirm- bzw.
Fensterkoordinaten, z-Wert zwischen (0,1), Rasterisierung
Viewport-Transformation
Typische Programmstruktur
void display(void) {
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0.0, 0.0, 0.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0,0,1, 0,0,0, 0,1,0);
glTranslatef(0,0,-1);
glRotatef(alpha, 1.0, 0.0, 0.0);
glRotatef(beta, 0.0, 1.0, 0.0);
glRotatef(gamma, 0.0, 0.0, 1.0);
glutWireTeapot(0.5);
glFlush ();
}
void reshape (int w, int h) {
glViewport(0,0,(GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(90.0, (float) w/h, 1, 120);
glMatrixMode(GL_MODELVIEW);
}
sphere_pers.c
Nachtrag: Perspektive
Am Beispiel der Kugel wird das Problem sehr schön deutlich
Blick auf die Kugel entspricht einem Kegel
Projektion auf Bildebene entspricht einem
Kegelschnitt
Ellipse
Je größer der
Kameraöffnungswinkel
gewählt wird, desto schiefer („ellipsiger“) werden die
Kugeln
Das gleiche beim RayTracer
Bildebene Augpunkt
Blickrichtung
Vorsicht bei Perspektive:
Öffnungswinkel nicht zu groß wählen!
90° 60° 45°
Rasterisierung
Wie bekommt man die z-Koordinate innerhalb einer Fläche?
Genauso wie die Farbe, durch lineare Interpolation (Gouraud- Shading):
( )
12 1 l L
L l
A= ⋅ + − ⋅
( )
12 1 r R
R r
E = ⋅ + − ⋅
(
t)
AE t
P = ⋅ + 1− ⋅
L
1L
2R
1R
2A P E
wobei
- L1,L2,R1,R2,A,E,P in 2D-
Bildschirmkoordinaten gegeben sind
- mit Hilfe der r,l,t Werte die
entsprechenden Werte (Farbe, Tiefenwert) interpoliert werden
Nichtlin. Skalierung p '
z= n + f − nf p
zn f
n f
p'
zp
zL
1L
2R
1R
2A P E
Dürfen diese Tiefenwerte im Bild linear interpoliert werden?
Genauere Betrachtung
1 1
-1
x z
y
-1
0
Perspektivische Projektion
verändert auch die Koordinaten!
A‘
E‘
P‘ t‘
1-t‘ P t
E
t
t ' ≠
Wie hängt t und t‘ zusammen?
⋅
−
+
⋅
=
y x y
x y
x
a t a
e t e p
p
' ) '
' 1 ' (
' ' '
'
=
z y
z x
y x
p np
p np
p p ' '
⋅
⋅
−
+
⋅
⋅
=
⋅
y x y z
x y z
x
z
a
a a
t n e
e e
t n p
p p
n ' ( 1 ' )
A‘
E‘
P‘t‘
1-t‘ P t
E
⋅
⋅
−
+
⋅
⋅
=
y x z
z y
x z
z y
x
a a a
t p e
e e
t p p
p ' ( 1 ' )
t 1 − t
Gerade im Bild
… entstand aus perspekt. Projektion
z z
e t p t = ' ⋅
z z
a t p
t = − ⋅
− ) ( 1 ' )
1 (
Wichtig später für Texturen !
Bedeutung
Bei der Rasterisierung gehen wir im Bild die Scanlines durch (dies entspricht dem Parameter t‘) und erhalten den Punkte p‘ im Bild.
Der dazugehörige Punkt p im Raum ist nicht mit dem gleichen Parameter t‘ zu erreichen. (Längenverhält- nisse sind bei perspektivischen Projektionen nicht invariant).
Hierfür müssen wir den Parameter rückprojizieren mit:
z z
e t p t = ' ⋅
z z
a t p
t = − ⋅
− ) ( 1 ' )
1 (
e p
w t w t = ' ⋅
a p
w t w
t = − ⋅
− ) ( 1 ' )
1
(
bzw.
Was passiert genau mit z ?
Der gültige z-Wert ergibt sich durch die Interpolation im 3D
A‘
E‘
P‘t‘
1-t‘ P t
z E
z
z
t e t a
p = ⋅ + ( 1 − ) ⋅
Gerade im 3D
Ersetzen durch t‘ im Bild
ergibt:
Umformung lie- fert schließlich:
z z
e t p
t = ' ⋅
(1-t)… wäre ge-nauso möglich
z z
z z z
z z
a
e t p e e
t p
p = ' ⋅ ⋅ + ( 1 − ' ⋅ ) ⋅
( )
z z
z
t a
t e p
' 1 1 1
1 '
⋅
− +
=
Bedeutung
Wir dürfen die z-Werte der Eckpunkte im Bild nicht linear interpolieren!
Tatsächlich ergibt sich der entsprechende z-Wert eines Punktes p durch lineare Interpolation der 1/z Werte der Eckpunkte.
( )
z z
z
t a
t e p
' 1 1 1
1 '
⋅
− +
=
Tiefenwert in OpenGL…
…darf direkt linear interpoliert werden.
A‘
E‘
P‘t‘
1-t‘ P t
E
z z
z
t e t a
p ' = ' ⋅ ' + ( 1 − ' ) ⋅ '
Gerade im Bild
Denn für den Tiefen- wert tragen wir nicht z ein, sondern:
z
z
n f nf p
p ' = + −
(
z) (
z)
z
t n f nf e t n f nf a
p nf f
n + − = ' ⋅ + − + ( 1 − ' ) ⋅ + −
z z
z
t a
t e p
) 1 ' 1 1 (
1 '
− +
=
Einsetzen:
liefert:
Das heißt …
In OpenGL dürfen die
Tiefenwerte der Eckpunkte direkt interpoliert werden.
Hier liefert die lineare
Interpolation der Tiefenwerte bei der Rasterisierung die
perspektivisch korrekten z-Werte.
Wir sparen uns also die Division durch die z-Koordinaten pro Pixel bei der Rasterisierung
Bei den Texturen ist dagegen eine Rückprojektion der
Parameter (pro Pixel) notwendig:
A‘
E‘
P‘t‘
1-t‘ P t
z E
z
z
t e t a
p ' = ' ⋅ ' + ( 1 − ' ) ⋅ '
z z
z
t a
t e p
) 1 ' 1 1 (
1 '
− +
=
e p
w t w t = ' ⋅
a p
w t w
t = − ⋅
− ) ( 1 ' )
1 (
entspricht:
Beispiel
Teapot und umgebender Würfel bei z = -2
Perspektivische Projektion mit Öffnungswinkel 60° auf ein quadratisches Fenster im Tiefenbereich von 1 bis 3
x z
y
0
Ergebnis
Perspektivischer Blick von vorne Orthographische
Projektion von vorne
x z
y
0
Was passiert, …
Frage: was passiert, wenn man Rotation auf Projektionsmatrix ausführt?
glViewport(0,0,300,300);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glRotatef(alpha, 0.0, 1.0, 0.0);
gluPerspective(60,1,1,3);
draw();
Rotation der Projektionsmatrix
Orthogr. Transformation mit Rotation:
Der Blick von der Seite auf das Viewfrustum mit äquidistanten z-Werten
Persp. Transformation mit Rotation:
Der Blick von der Seite auf das kanonische Volumen (nicht-lineare Skalierung der z-Werte)
(ursprüngliche Blickrichtung) (ursprüngliche Blickrichtung)
Weiteres Beispiel
x z
y
0
Rechteck, unterteilt in gleiche Quadrate, füllt das View
Frustum wie gezeichnet aus.
Ergebnis
Resultat: man sieht, dass die Koordinaten im Bild nicht direkt als Texturkoordinaten interpretiert werden dürfen.
Der (orthographische) Blick von der Seite auf das View Frustum mit äquidistanten z-Werten
(urspr. Blickrichtung)
View Frustum von der Seite
Persp. Transformation:
Der Blick von der Seite auf das kanonische Volumen
„gestauchtes“ Frustum (urspr. Blickrichtung)
=
z z y
z x
z y x
p p np
p np
p p p ' ' '
− +
=
z z y
z x
z y x
p nf f
n
p np
p np
p p p ' ' '
(urspr. Blickrichtung)
„gestauchtes“ Frustum mit nicht-linearer z-Skalierung
Das letzte Beispiel zeigt…
… warum die Tiefenwerte (1/z-Werte) bei der
Rasterisierung linear interpoliert werden dürfen/müssen
Die Texturkoordinaten aber noch perspektivisch verzerrt werden müssen
persp_volume2.c
Fazit
Bei OpenGL werden im Tiefenpuffer die 1/z-Werte eingetragen
Nach einer perspektivischen Projektion werden
die Tiefenwerte bei der Rasterisierung linear interpoliert (ähnlich den Farben, etc.)
• effiziente Lösung, da wir nicht bei der Rasterisierung durch z teilen müssen
bei den Texturkoordinaten muß hier noch p
z/a
zbzw. w
z/w
akorrigiert werden, da sonst perspektivisch nicht korrekt
verzerrt.
Materialien und Beleuchtung
Zusätzliche Eckpunktattribute
State machine: an jedem Eckpunkt wird der aktuelle Zustand verwendet, d.h. erst muß die Farbe etc.
definiert werden, dann der Eckpunkt glBegin(GL_POLYGON);
glColor3f(1,0,0);
glVertex3f(0,0,0);
glVertex3f(1,0,0);
glVertex3f(.5,1,0);
glEnd();
Zusätzliche Eckpunktattribute
Änderungen pro Eckpunkt möglich glBegin(GL_POLYGON);
glColor3f(0,0,1);
glVertex3f(0,0,0);
glColor3f(0,0,1);
glVertex3f(1,0,0);
glColor3f(1,0,0);
glVertex3f(.5,1,0);
glEnd();
Farbinterpolation
Die Farbe muß nicht interpoliert werden
glShadeModel( {GL_FLAT,GL_SMOOTH} ); bestimmt, ob interpoliert wird
bei GL_FLAT bestimmt die Farbe des letzten Eckpunktes (Ausnahme GL_POLYGON: erster)
1.
5.
4.
3.
2.
6.
1.
5.
4.
3.
2.
6.
GL_FLAT
GL_SMOOTH
Beleuchtung
Ohne Beleuchtung wirken die Objekte sehr flach, Formen sind schwer zu erkennen
OpenGL verwendet klassisches Beleuchtungsmodell:
allgemeines Umgebungslicht
Lichtquellen und Materialien mit
• Umgebungslicht (ambient)
• diffuser Reflexion (diffuse)
• spiegelnder Reflexion (specular)
• Eigenausstrahlung von Materialien (emission)
Diffuse Oberfläche (Lambert…)
In der Computergraphik werden Oberflächen- materialien oft als „ideal diffus“ betrachtet.
Egal von welcher Richtung man auf die Fläche sieht:
sie wirkt immer gleich hell.
Beispiel: Blatt Papier
M
dDiffuse Oberfläche (Lambert…)
Entscheidend ist aber der Einfallswinkel des Lichts
ϕ
M
dϕ M
dϕ M
dSenkrechter Lichteinfall:
Sehr hell Waagrechter Lichteinfall:
Sehr dunkel
Lambert-Gesetz
ϕ
M
dϕ
M
dϕ
M
dDie „sichtbare“ Fläche nimmt mit dem cos des Einfallswinkels ab:
ϕ
⋅ cos
⋅
b g r
b g r
L L L M
M M
Materialfarbe · Lichtfarbe
·
cosϕ ϕ: Winkel zwischen Oberflächen- normalen und Lichteinfallϕ A
n
ϕ
⋅ cos A
Bemerkung
Bei den Farben handelt es sich um rgb-Vektoren
Die Multiplikation ist eine „komponentenweise“
Multiplikation (Licht hat seine eigene Mathematik …)
Beispiel:
Material rot, Licht 1 ist weiß (Resultat: rotes Licht)
Material rot, Licht 2 ist grün (Resultat: schwarz)
ϕ
⋅ cos
⋅
b g r
b g r
L L L M
M
M
Spiegelnder Term (Phong …)
Glanz/Spiegelung tritt entlang des reflektierten Lichtvektors auf
Blickt man in die „Spiegelung“ des Lichtvektors, ist der Glanz sehr hell.
ψ
ψ
n
b g r
b g r
L L L M
M M
⋅ cos
⋅
n: Glanzzahl
ψ: Winkel zw. reflektiertem
Lichtstrahl und Blickrichtung
Glanzzahl
= 0
n n = 1
= 5
n n = 100
N = 5 N = 15
ψ
cos
nψ
Phong-Beleuchtungsmodell
Materialien bestehen aus
Diffuser Komponente
Spiegelnder Komponente
Problem
„Abgewandte“ Flächen sind schwarz
Lösung:
Ambienter Term
Wird immer aufaddiert
( )
iLq i
i n s
i d
a
d
L M M L
M
L = ⋅ + ∑ ⋅ + ⋅
=
# 1
cos
cos ϕ ψ
Phong-Beleuchtungsmodell
M
d: diffuse Materialfarbe
M
s: spiegelnde Materialfarbe L
a: ambiente Lichtfarbe
L
i: Farbe der Lichtquelle i n: Glanzahl
Alle Terme (M, L) sind rgb- Farben
Für den zu beleuchtenden Oberflächenpunkt muss die Normale bekannt sein
Freiheit: die Materialfarbe kann von der spiegelnden Materialfarbe verschieden sein
Problem: Die Summe aller Farben kann größer 1
( )
iLq i
i n s
i d
a
d
L M M L
M
L = ⋅ + ∑ ⋅ + ⋅
=
# 1
cos
cos ϕ ψ
OpenGL-Beleuchtung
Klassisches
Beleuchtungsmodell
Viele Freiheiten
Die einzelnen Anteile werden dann aufsummiert um die Farbe des Punktes zu erhalten
Werte größer 1 werden auf 1 geclampt
Global
Ambiente Lichtfarbe
Materialien
Emissionsfarbe
Ambiente Reflexion(sfarbe)
Diffuse Reflexion(sfarbe)
Spiegelnde Reflexion(sfarbe)
Glanzzahl
Für jede Lichtquelle
Position
Ambiente Lichtfarbe
Diffuse Lichtfarbe
Spiegelnde Lichtfarbe
( )
∑
=⋅ +
⋅
⋅ +
⋅ +
⋅ +
=
Lqi
i s i
n s
i d i
d i
a a
a a
e
M L M L M L M L
M L
# 1
, ,
,
cos ϕ cos ψ
Materialemission
Emission dient zur Simulation selbstleuchtender Materialien, die allerdings keine anderen Objekte beleuchten. Die Emissionsfarbe wird einfach als Basishelligkeit genommen.
Parameter: Emissionsfarbe M
e( )
∑
=⋅ +
⋅
⋅ +
⋅ +
⋅ +
= Lq
i
i s i n s
i d i d
i a a a
a
e M L M L M L M L
M L
# 1
, ,
, cosϕ cos ψ
Ambiente Beleuchtung
Simuliert gestreutes Umgebungslicht
völlig unabhängig von der Geometrie
Parameter: Ambiente Reflexion(sfarbe) M
a, ambiente Lichtfarbe L
a
Gibt es als globalen Wert und pro Lichtquelle
( )
∑
=⋅ +
⋅
⋅ +
⋅ +
⋅ +
= Lq
i
i s i n s
i d i d
i a a a
a
e M L M L M L M L
M L
# 1
, ,
, cosϕ cos ψ
Diffuse Beleuchtung
Entspricht der Abstrahlung matter Oberflächen
abhängig von Oberflächennormale und Lichteinfall
Parameter: Diffuse Reflexion(sfarbe) M
d, Lichtfarbe L
dϕ
M
d( )
∑
=⋅ +
⋅
⋅ +
⋅ +
⋅ +
= Lq
i
i s i n s
i d i d
i a a a
a
e M L M L M L M L
M L
# 1
, ,
, cosϕ cos ψ
Spiegelnde “Beleuchtung”
simuliert Spiegelungseffekte
abhängig von Blickrichtung und reflekt. Lichtrichtung
Parameter: Spiegelnde Reflexion(sfarbe) M
s&
Lichtfarbe L
s, Glanzzahl n
ψ
N = 5 N = 15
( )
∑
=⋅ +
⋅
⋅ +
⋅ +
⋅ +
= Lq
i
i s i n s
i d i d
i a a a
a
e M L M L M L M L
M L
# 1
, ,
, cosϕ cos ψ
Materialien
Ähnlich wie bei den Lichtquellen über eine Funktion:
glMaterial{if}[v](side, name, value);
side: GL_FRONT, GL_BACK oder GL_FRONT_AND_BACK
name: GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR,
GL_EMISSION, GL_AMBIENT_AND_DIFFUSE erwarten eine RGBA-Farbe
Die Glanzzahl kann über GL_SHININESS gesetzt werden
lightmaterial.exe
Nate Robin
Lichtquellen
von einigen Features gibt es mehr als eine Instanz, z.B. Lichtquellen, Clip-Planes etc.
diese werden meist über eine Funktion, die als ersten Parameter eine Kennzeichnung der Instanz hat,
manipuliert, z.B.
glLightf( GL_LIGHT0, …, … );
setzt einen Wert für die 1. Lichtquelle
die Konstanten sind fortlaufend nummeriert
GL_<CONST>i = GL_<CONST>0 + i
Lichtquellenparameter
Alle Parameter werden gesetzt durch
glLight{if}[v](GL_LIGHTi, GLenum name, value);
die maximale Lichtquellen-Anzahl kann durch
glGet(GL_MAX_LIGHTS) abgefragt werden (typischerweise 8 Lichtquellen)
jede Lichtquelle hat 3 Farbwerte (jeweils RGBA):
ambiente Stärke (GL_AMBIENT)
diffuse Stärke (GL_DIFFUSE)
spekulare Stärke (GL_SPECULAR)
Lichtquellenparameter
Jede Lichtquelle hat eine GL_POSITION
Homogene Koordinate entscheidet, ob
Punktlichtquelle oder „gerichtete Lichtquelle“
