{{Bildwunsch|Ein Multitexturing-Beispielbild. Das Detailmapping Bild von Sascha wird schon zu oft verwendet. ;) }}
= glMultiTexCoord =

== Name ==
'''glMultiTexCoord''' - setzt die aktuellen Texturcoordinaten bei [[Multitexturing]].

== Delphi-Spezifikation ==
procedure '''glMultiTexCoord1i'''(''target'' : GLenum; ''s'' : GLint);
procedure '''glMultiTexCoord2i'''(''target'' : GLenum; ''s'' : GLint; ''t'' : GLint);
procedure '''glMultiTexCoord3i'''(''target'' : GLenum; ''s'' : GLint; ''t'' : GLint; ''r'' : GLint);
procedure '''glMultiTexCoord4i'''(''target'' : GLenum; ''s'' : GLint; ''t'' : GLint; ''r'' : GLint; ''q'' : GLint);

procedure '''glMultiTexCoord1iv'''(''target'' : GLenum; const ''v'' : PGLint);
procedure '''glMultiTexCoord2iv'''(''target'' : GLenum; const ''v'' : PGLint);
procedure '''glMultiTexCoord3iv'''(''target'' : GLenum; const ''v'' : PGLint);
procedure '''glMultiTexCoord4iv'''(''target'' : GLenum; const ''v'' : PGLint);

Außer den hier gezeigten Versionen für {{INLINE_CODE|[[GLint]]}}(i,iv) gibt es den Befehl noch für:
* {{INLINE_CODE|[[GLdouble]]}}(d,dv)
* {{INLINE_CODE|[[GLfloat]]}}(f,fv)
* {{INLINE_CODE|[[GLshort]]}}(s,sv)

== Parameter ==

{| border="1" rules="all"
! ''target''
| Bestimmt die Textureinheit, deren Koordinaten geändert werden soll. Die Anzahl der verfügbaren Textureinheiten ist Implementationsabhängig, muss aber mindestens zwei sein. ''target'' muss als Wert eine der '''GL_TEXTURE'''i Konstanten zugewiesen werden, wobei 0 < i < '''GL_MAX_TEXTURE_UNITS - 1''' sein muss. ('''GL_MAX_TEXTURE_UNITS''' ist eine implementationsabhängige Konstante)
|-
! ''s,t,r,q''
| Bestimmt die s,t,r und q Texturkoordinate der gewählten Textureinheit. Der Initilisierungwert ist (0, 0, 0, 1). (''Nur bei Variante ohne '''v''' im Namen.)
|-
! ''v''
| Ist ein Pointer auf ein Feld, welches die Texturkoordinaten in der Reihenfolge s,t,r,q enthält. Die Länge des Feldes ist dabei von der Befehlsversion abhängig.(1-4 Werte) (''Nur bei Variante mit '''v''' im Namen.)
|}

== Beschreibung ==
'''glMultiTexCoord''' definiert die Texturkoordinaten (s, t, r, q) für 1 bis 4 Dimensionen. Je nach genutzer Funktion werden die Koordinaten auf folgende Werte gesetzt:

{|{{Prettytable_B1}}
!Funktion
!Wert
|-
|glMultiTexCoord1
|(s, 0, 0, 1)
|-
|glMultiTexCoord4
|(s, t, 0, 1)
|-
|glMultiTexCoord4
|(s, t, r, 1)
|-
|glMultiTexCoord4
|(s, t, r, q)
|-
|}

Die aktuellen Texturkoordinaten sind Teil der Daten die sich auf jeden [[Vertex]] auswirken.

== Hinweise ==
'''glMultiTexCoord''' ist nur verfügbar, wenn die OpenGL-Version 1.3 oder höher ist, oder wenn die Erweiterung '''ARB_multitexture''' unterstützt wird.

Die aktuellen Texturkoordinaten können jederzeit geändert werden. D.h. insbesondere, dass diese Funktion innerhalb eines [[glBegin]]/glEnd Blocks aufgerufen werden kann.

Es gilt immer: '''GL_TEXTURE'''i = '''GL_TEXTURE0''' + i

== Zugehörige Wertrückgaben ==
[[glGet]] mit Token [[glGet#GL_CURRENT_TEXTURE_COORDS|GL_CURRENT_TEXTURE_COORDS]]

[[glGet]] mit Token [[glGet#GL_MAX_TEXTURE_COORDS|GL_MAX_TEXTURE_COORDS]]

== Siehe auch ==
[[glActiveTexture]], [[glClientActiveTexture]], [[glColor]], [[glGetIntegerv]], [[glNormal]], [[glTexCoordPointer]]

[[Kategorie:GL|MultiTexCoord]]
[[Kategorie:GL1.3]]

Beleuchtung

2010-01-22T15:40:43Z

Global667: /* ambientes Licht */ rs

Wie dem ein oder anderen bereits bekannt sein dürfte unterstützt [[OpenGL]] ja Lichtquellen. Ohne Beleuchtung wirkt alles platt und öde. Kugeln sehen aus wie Kreise und irgendwie kommt keine 3D Stimmung auf. Erst durch Licht wird aus dem "Na ja..." ein "Ahhh!".
Dieser Artikel soll dem ein oder anderen nocheinmal nahebringen, wie die Lichteffekte (räumlicher Eindruck, Glanzpunkte) auf Oberflächen durch OpenGL berechnet werden.

==Vorwissen==
Wie jeder wissen sollte, haben alle Objekte in OpenGL eine Farbe. Die Lichtberechnung fügt kein Licht im eigentlichen Sinne hinzu (wie auch? Sollte OpenGL Photonenteilchen implementieren? Einen "Lichtkegel" oder "Lichtstrahl" als solchen gibt es also nicht.), sondern ändert die Farbwerte entsprechend bestimmten Bedingungen (die Formeln die später noch folgen werden) ab.

OpenGL benutzt für die Lichtberechnung das sogenannte Phong-Modell. Dieses kennt 3 verschiedene Lichtkomponenten:
* ambientes Licht: Ein gleichmäßiges Licht, welches alle Punkte der Welt gleichmäßig ausleuchtet.
* diffuses Licht: Ein Omnidirektionales Licht welches Punkte abhängig von ihrer Position ausleuchtet.
* spekulares Licht: Der Lichtanteil der Glanzpunkte auf glatten Oberflächen erzeugt.

Beim letzten Punkt sieht man bereits, dass es mit dem Licht allein nicht getan ist. Auch die Eigenschaften von Oberflächen, also das '''Material''' aus dem diese bestehen wirkt sich auf die Lichtberechnung aus. OpenGL bietet in Sachen Materialen folgende Eigenschaften.

===Materialien===
{{Warnung|Die Auswahl ist nicht komplett. Sie beschränkt sich auf die wichtigsten Parameter. Genauere Hinweise findet ihr unter [[glMaterial]].}}

'''GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR'''
: mit diesem Materialparametern könnt ihr einstellen, wie das Material die einzelnen Lichtkomponenten reflektieren soll. Die übergeben Werte an diese Parameter gleichen Farbwerten und entsprechen der Farbe der reflektierten Lichtkomponente.

'''GL_EMISSION'''
: Material kann auch selbstleuchtend sein. Mit diesem Parameter könnt ihr einstellen, wie stark und in welcher Farbe das Material leuchten soll.

'''GL_SHININESS'''
: mit diesem Parameter könnt ihr den Glanzlichtexponenten einstellen. Was das ist seht ihr in der Berechnungsformel für das Glanzlicht.

{{Hinweis|Das DGL-Wiki verfügt über eine umfangreiche '''[[Materialsammlung]]''' aus der man passende Parameterwerte entnehmen kann.}}

===Licht===
Die Eigenschaften des Lichts sind ebenfalls recht vielfältig. Neben den verschiedenen Lichtanteilen kann auch die Lichtrichtung, die Position der Lichtquelle und noch einiges mehr eingestellt werden. Welche Parameter es gibt könnt ihr im Artikel [[glLight]] nachlesen.

Für die nachfolgenden Berechnung sind hauptsächlich nur die Eigenschaften

'''GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR'''
: mit diesem Materialparametern könnt ihr einstellen, wie stark und in welcher Farbe die einzelnen Lichtkomponenten leuchten sollen.

und

'''GL_POSITION'''
: diese Eigenschaft bestimmt wo die Lichtquelle (in Raumkkordinaten) plaziert ist.

Weiterhin kann über '''GL_SPOT_CUTOFF''' die Streuung der Lichtquelle eingestellt werden. Die nachfolgenden Formeln gehen davon aus, dass ein Punkt tatsächlich beleuchtet wird (quasi wird eine gleichmäßige Abstrahlung in alle Richtungen angenommen).

==Berechnung==
===ambientes Licht===
Ambientes Licht sorgt für eine Art Grundbeleuchtung. Das ambiente Licht wirkt sich gleichmäßig auf alle Farbwerte eines jeden Vertexes aus. Bei der „Standardbeleuchtung“ von OpenGL (wenn Licht noch ausgeschaltet ist) wirken zum Beispiel Kugeln eher wie Kreise. Ambientes Licht ändert daran nichts. Denn '''alle''' Vertexe der Kugel werden gleich beleuchtet. Ambientes Licht dient nur dazu eine bestimmte Grundhelligkeit zu erzeugen. Vergleichbar mit dem Licht im Morgengrauen.

Die '''Formel für ambientes Licht''' lautet:

[[Bild:Bel_Amb_Formel.png]] 
Der Materialkoeffizient ist die "Farbe", die man in den Materialeigenschaften für das ambiente Licht eingestellt hat.

===diffuses Licht===
Auch diffuses Licht wird auf alle Vertexe angewandt. Der Unterschied zu ambienten licht ist aber, dass bei der Berechnung nun auch die Position des zu beleuchtenden Punktes eine Rolle spielt. Dadurch entsteht dann auch der räumliche Eindruck (Plastizität).Cos alpha kann über das Skalarprodukt aus Normalenvektor und Lichtquellenvektor bestimmt werden.

Die '''Formel für diffuses Licht''' ist dafür etwas komplizierter:

[[Bild:Bel_Diff_Formel.png]]

Als Verständinshilfe hier eine kleine Skizze:

[[Bild:Bel_Diff_Skizze.png]]

===spekulares Licht (Glanzlicht)===
Als krönender Abschluss noch die Glanzlichtberechnung. Jeder kennt die Glanzpunkte auf glatten Oberflächen (z.B. Billiardkugel). Die Formel ähnelt der für diffuses Licht. Allerdings streuen glatte Oberflächen weniger das Licht als stumpfe. Dadurch entsteht der bekannte Glanzpunkt.Cos beta kann über das Skalarprodukt zwischen Reflexionsvektor und Beobachtervektor bestimmt werden oder über das Skalarprodukt zwischen der Winkelhalbierenden H(zwischen Lichtquellenvektor und Beobachtervektor) und dem Normalenvektor.

{{Warnung|In diesem Artikel wird das Phong-Modell beschrieben. OpenGL verwendet jedoch das leicht veränderte und schnellere Blinn-Phong-Modell. Weitere Details finden sich auf der [[Diskussion:Beleuchtung|Diskussionsseite]].}}

Die "Formal für spekulares Licht":

[[Bild:Bel_Spec_Formel.png]]

Hier ist besonders der Exponent über dem Kosinus zu erwähnen. Dieser kann über die eingangs erwähnte Lichteigenschaft '''GL_SHININESS''' expliziet eingestellt werden. Die Wirkung des Exponenten wird an der nachfolgenden Skizze erklärt.

[[Bild:Bel_Spec_Skizze.png]]
Beta ist also der Winkel zwischen dem direkten reflektierten Strahl und der Blickrichtung.

Je größer '''m''' wird desto kleiner und deutlicher wird der Glanzpunkt und desto glatter wirkt die Oberfläche.
Die geometrische Wirkung von '''m''' kann man sich ungefähr so vorstellen:
: Je größer '''m''' wird desto mehr Licht aus dem Bereich ''Beta'' wird direkt zum Auge gespiegelt und nicht gestreut.

===gesamtes Licht für einen Vertex===
Da alle Lichtkomponenten auf einen Vertex einwirken, ergibt sich die entgültige Färbung eines Vertex durch:

[[Bild:Bel_Ges_Formel.png]]

Hier tauchen dann auch die selbstleuchtenden Materialien wieder auf.

==OpenGL Befehle==
Folgende Befehle werden im Zusammenhang mit Licht benutzt:

[[glLight]] 
[[glEnable]] mit '''GL_LIGHT'''i und '''GL_LIGHTING''' 
[[glMaterial]]

==Siehe Auch==
[[Normalen]]

2009-08-06T03:25:30Z

Global667:

Datei:TransMatrix.png

2009-08-06T03:24:51Z

Global667:

glLoadTransposeMatrix

2009-08-06T03:17:33Z

Global667: /* Name */ Link korrigiert

= glLoadTransposeMatrix =

== Name ==
'''glLoadTransposeMatrix''' - ersetzt die aktuelle Matrix durch eine beliebige, [[Matrix_Transposition|transponierte]] 4x4-Matrix auf dem [[Matrixstack]].

== Delphi-Spezifikation ==
'''procedure''' glLoadTransposeMatrixd('''const''' ''m'': PGLdouble); 
'''procedure''' glLoadTransposeMatrixf('''const''' ''m'': PGLfloat);

== Parameter ==
{| border=1 rules=all
! ''m''
| Ein Zeiger auf eine 4x4-Matrix, welche die aktuelle Matrix ersetzen soll.
|}

== Beschreibung ==
'''glLoadTransposeMatrix''' arbeitet fast genauso wie [[glLoadMatrix]], nur dass die Werte der Matrix zusätzlich an der Hauptdiagonalen gespiegelt werden.

Abhängig vom aktuellen Matrix-Modus ([[glMatrixMode]]) wird dadurch die Projektions-Matrix, die Modelview-Matrix oder die Texture-Matrix ersetzt (siehe dazu [[Matrix#Die_drei_OpenGL_Matrizen|"Die_drei_OpenGL_Matrizen"]]). 
Der Parameter ''m'' zeigt auf eine 4x4-Matrix, welche zeilenweise Fließkommazahlen mit einfacher oder doppelter Genauigkeit (Single oder Double) enthält. 

Die Matrix muß also in der folgenden Reihenfolge gespeichert sein: 

+- -+
| 0 1 2 3 |
| 4 5 6 7 |
| 8 9 10 11 |
| 12 13 14 15 |
+- -+

== Hinweise ==
'''glLoadTransposeMatrix''' ist erst ab OpenGL Version 1.3 oder höher nutzbar.

== Fehlermeldungen ==
'''GL_INVALID_OPERATION''' wird generiert, wenn '''glLoadTransposeMatrix''' innerhalb eines [[glBegin]]-[[glEnd]] Blocks aufgerufen wird.
 
== Zugehörige Wertrückgaben ==
[[glGet]] mit Token '''GL_MATRIX_MODE''' 
[[glGet]] mit Token '''GL_COLOR_MATRIX''' 
[[glGet]] mit Token '''GL_TRANSPOSE_COLOR_MATRIX''' 
[[glGet]] mit Token '''GL_MODELVIEW_MATRIX''' 
[[glGet]] mit Token '''GL_TRANSPOSE_MODELVIEW_MATRIX''' 
[[glGet]] mit Token '''GL_PROJECTION_MATRIX''' 
[[glGet]] mit Token '''GL_TRANSPOSE_PROJECTION_MATRIX''' 
[[glGet]] mit Token '''GL_TEXTURE_MATRIX''' 
[[glGet]] mit Token '''GL_TRANSPOSE_TEXTURE_MATRIX''' 

== Siehe auch ==
[[glLoadIdentity]], [[glLoadMatrix]], [[glMatrixMode]], [[glMultMatrix]], [[glMultTransposeMatrix]], [[glPopMatrix]], [[glPushMatrix]]

[[Kategorie:GL|LoadTransposeMatrix]]
[[Kategorie:GL1.3]]

glLoadTransposeMatrix

2009-08-06T03:15:21Z

Global667: /* Name */

= glLoadTransposeMatrix =

== Name ==
'''glLoadTransposeMatrix''' - ersetzt die aktuelle Matrix durch eine beliebige, [[Matrix|transponierte]] 4x4-Matrix auf dem [[Matrixstack]].

== Delphi-Spezifikation ==
'''procedure''' glLoadTransposeMatrixd('''const''' ''m'': PGLdouble); 
'''procedure''' glLoadTransposeMatrixf('''const''' ''m'': PGLfloat);

== Parameter ==
{| border=1 rules=all
! ''m''
| Ein Zeiger auf eine 4x4-Matrix, welche die aktuelle Matrix ersetzen soll.
|}

== Beschreibung ==
'''glLoadTransposeMatrix''' arbeitet fast genauso wie [[glLoadMatrix]], nur dass die Werte der Matrix zusätzlich an der Hauptdiagonalen gespiegelt werden.

Abhängig vom aktuellen Matrix-Modus ([[glMatrixMode]]) wird dadurch die Projektions-Matrix, die Modelview-Matrix oder die Texture-Matrix ersetzt (siehe dazu [[Matrix#Die_drei_OpenGL_Matrizen|"Die_drei_OpenGL_Matrizen"]]). 
Der Parameter ''m'' zeigt auf eine 4x4-Matrix, welche zeilenweise Fließkommazahlen mit einfacher oder doppelter Genauigkeit (Single oder Double) enthält. 

Die Matrix muß also in der folgenden Reihenfolge gespeichert sein: 

+- -+
| 0 1 2 3 |
| 4 5 6 7 |
| 8 9 10 11 |
| 12 13 14 15 |
+- -+

== Hinweise ==
'''glLoadTransposeMatrix''' ist erst ab OpenGL Version 1.3 oder höher nutzbar.

== Fehlermeldungen ==
'''GL_INVALID_OPERATION''' wird generiert, wenn '''glLoadTransposeMatrix''' innerhalb eines [[glBegin]]-[[glEnd]] Blocks aufgerufen wird.
 
== Zugehörige Wertrückgaben ==
[[glGet]] mit Token '''GL_MATRIX_MODE''' 
[[glGet]] mit Token '''GL_COLOR_MATRIX''' 
[[glGet]] mit Token '''GL_TRANSPOSE_COLOR_MATRIX''' 
[[glGet]] mit Token '''GL_MODELVIEW_MATRIX''' 
[[glGet]] mit Token '''GL_TRANSPOSE_MODELVIEW_MATRIX''' 
[[glGet]] mit Token '''GL_PROJECTION_MATRIX''' 
[[glGet]] mit Token '''GL_TRANSPOSE_PROJECTION_MATRIX''' 
[[glGet]] mit Token '''GL_TEXTURE_MATRIX''' 
[[glGet]] mit Token '''GL_TRANSPOSE_TEXTURE_MATRIX''' 

== Siehe auch ==
[[glLoadIdentity]], [[glLoadMatrix]], [[glMatrixMode]], [[glMultMatrix]], [[glMultTransposeMatrix]], [[glPopMatrix]], [[glPushMatrix]]

[[Kategorie:GL|LoadTransposeMatrix]]
[[Kategorie:GL1.3]]

glScale

2009-08-06T03:03:58Z

Global667: /* Beschreibung */

= glScale =
 

== Name ==
'''glScale''' - bewirkt eine Verzerrung oder Spiegelung des Koordinatensystems.
 
== Delphi-Spezifikation ==
'''procedure''' glScaled(''x'', ''y'', ''z'': TGLdouble); 

'''procedure''' glScalef(''x'', ''y'', ''z'': TGLfloat);
 

== Parameter ==
<table border=1>
<tr>
<td>''x, y, z''</td>
<td>Die einzelnen Parameter bestimmen die Verzerrung für die einzelnen Achsen</td>
</tr>
</table>
 

== Beschreibung ==
[[Bild:Tutorial Matrix2 Scale.png|344px|thumb|right|Skalierung des Koordinatensystems durch den Aufruf von '''glScalef(0.8,1,0.6);'''(''Auf Bild klicken zum vergrößern'') Weitere Erklärungen im [[Tutorial Matrix2]].]]

Die Funktion '''glScale''' bewirkt eine Verzerrung oder Spiegelung des Koordinatensystems.

Hierfür wird eine Skalierungsmatrix mit der [[glMatrixMode|aktuellen]] [[Matrix]] multipliziert. 
Die Skalierungsmatrix sieht so aus:

<div align="center"> [[Bild:GlScale.png]]</div>

wobei x, y, z den übergebenen Parametern entspricht.

== Hinweise ==
'''Es sollte um jeden Preis vermieden werden, eine Achse auf 0 zu skalieren''' (''x,y'' und ''z'' immer <> 0.0)! Dies führt dazu, dass die aktuelle Matrix [http://www.math.unizh.ch/fachverein/forum/detail.jsp?FORUM=120 singulär] wird und Funktionen wie [[gluProject]] sowie [[gluUnProject]] nicht mehr korrekt funktionieren.

== Fehlermeldungen ==
GL_INVALID_OPERATION wird generiert wenn glScale zwischen einem [[glBegin]] und dem zugehörigen [[glBegin|glEnd]] aufgerufen wird.
 
== Zugehörige Wertrückgaben ==
[[glGet]] mit Token '''GL_MATRIX_MODE''' 
[[glGet]] mit Token '''GL_MODELVIEW_MATRIX''' 
[[glGet]] mit Token '''GL_PROJECTION_MATRIX''' 
[[glGet]] mit Token '''GL_TEXTURE_MATRIX''' 

== Beispiele ==
<div align="center">
<table border=1>
<tr>
<td>[[bild:Glscale_normal.png]]</td>
<td>Ein ganz normaler Würfel der keinerlei Skalierung erfahren hat. Entspricht:'''glScale(1,1,1);'''</td>
</tr>
<tr>
<td>[[bild:Glscale_scaledx.png]]</td>
<td>Der gleiche Würfel, der diesmal entlang der X-Achse gestreckt wurde. Entspricht:'''glScale(3,1,1);'''</td>
</tr>
<tr>
<td>[[bild:Glscale_invert.png]]</td>
<td>Der vorige Würfel, der nun auch entlang der Y-Achse invertiert wurde. Entspricht:'''glScale(3,-1,1);'''</td>
</tr>
</table>
 
</div>

Weitere Beispiele bei [[Tutorial_Matrix2#Auswirkungen_von_Matrixmanipulationen_-_oder_.22Wie_positioniere_ich_meine_Objekte_richtig.3F.22|Tutorial Matrix2]].

== Siehe auch ==
[[glLoadMatrix]], [[glMatrixMode]], [[glMultMatrix]], [[glPushMatrix]], [[glRotate]], [[glTranslate]]

[[Kategorie:GL|Scale]]
[[Kategorie:GL1.0]]

Datei:GlScale.png

2009-08-06T03:02:10Z

Global667:

gluPerspective

2009-08-06T02:42:53Z

Global667: /* Beschreibung */ Matrix durch Latexbild ersetzt

= gluPerspective =

== Name ==
'''gluPerspective''' - Erstellt eine perspektivische Projektionsmatrix.

== Delphi-Spezifikation ==

procedure '''gluPerspective'''(''fovy'', ''aspect'', ''zNear'', ''zFar'' : ''glDouble'');

== Parameter ==

{| border="1" rules="all"
! ''fovy''
| Gibt das Betrachtungsfeld (FOV) in Grad, entlang der Y-Achse, an.
|-
! ''aspect''
| Gibt den Aspektratio, der das Betrachtungsfeld entlang der X-Achse setzt. Der Aspektratio ist das Verhältnis von Höhe zu Breite.
|-
! ''zNear''
| Entfernung vom Betrachter zur nahen Z-Schnittfläche (muss positiv sein).
|-
! ''zFar''
| Entfernung vom Betrachter zur fernen Z-Schnittfläche (muss positiv sein).
|}

== Beschreibung ==
'''gluPerspective''' beschreibt ein Betrachtungssichtfeld (Frustum) ins Weltkoordinatensystem hinein. Meistens setzt man den Aspektratio dabei gleich dem Aspektratio des zugewiesenen Viewports.
Die von '''gluPerspective''' erstellte Matrix wird mit der aktuellen Matrix multipliziert, so als ob man [[glMultMatrix]] mit der generierten Matrix aufgerufen hätte. Um die perspektivische Matrix zu setzen, sollte man zuerst [[glLoadIdentity]] und dann '''gluPerspective''' aufrufen.

Für ''f'' = cotangent(fovy/2), sieht die erstellte Matrix so aus :

<div align="center"> [[Bild:GluPerspective.png]]</div>

===Anwendung===
'''gluPerspective''' wird nur gebraucht wenn eine perspektivische Projektion benutzt werden soll. (siehe auch [[glOrtho]])
*Wo gehört '''gluPerspective''' hin?:
: In die Initialisierung des Forumulars um überhaupt eine Projektion zu erhalten.
: In die Behandlung des OnResize-Events, da die Projektion an die neuen Fenstermaße angepasst werden sollte.
: In den Render-Code wenn sich innerhalb des Renderdurchgangs die Projektion ändert.

*Wo gehört '''gluPerspective''' nicht hin?:
: In den Render-Code wenn sich die Projektion während des Rendervorgangs nicht ändert.

== Hinweise ==
Die Genauigkeit des Tiefenpuffer wird von den in ''zNear'' und ''zFar'' angegebenen Werten beeinflusst. Je größer das Verhältnis von ''zFar'' zu ''zNear'', je ineffektiver kann der Tiefenpuffer zwischen nah beieinander liegenden Oberflächen unterscheiden.
Wenn ''r'' = ''zFar'' / ''zNear'', dann gehen ungefähr log(2)r Bits and Tiefenpuffergenauigkeit verloren. Da ''r'' gegen Unendlich strebt wenn ''zNear'' gegen 0 strebt, darf ''zNear'' niemals gleich 0 gesetzt werden.

== Siehe auch ==
[[glFrustum]], [[glLoadIdentity]], [[glMultMatrix]], [[gluOrtho2D]]

[[Kategorie:GLU|Perspective]]

Datei:GluPerspective.png

2009-08-06T02:40:05Z

Global667: