DGL Wiki - Benutzerbeiträge [de]

gluPerspective

2010-10-06T17:32:13Z

Joni: einen Tippfehler korrigiert

= 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 Breite zu Höhe.
|-
! ''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 an 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]]

Shadersammlung

2010-03-11T14:39:04Z

Joni:

==Was sind Shader?==
Die traditionelle [[Feste_Funktionspipeline|Funktionspipeline]] der OpenGL ist sehr beschränkt, neuere [[Algorithmus|Algorithmen]] erfordern eine viel höhere Flexibilität. [[Shader]] sind kleine Programme die es erlauben Teile der Funktionspipeline völlig frei zu programmieren. Dies bietet völlig neue Möglichkeiten. Auf der einen Seite sind Shader für Einsteiger eine gewisse Hürde, auf der anderen Seite können sie viele Dinge aber auch enorm vereinfachen. Aus diesem Grund wurde in OpenGL 3.1 sowie OpenGL ES 2.0 die feste Funktionspipeline entfernt, so dass Shader dort verpflichtend sind.

Der Artikel [[Shader]] gibt einen ausführlichen Überblick zum Thema sowie eine [[Shader#Wie_geht_es_nun_weiter.3F|Linksammlung]] für den Einstieg.

==Shader hinzufügen==
Die Shadersammlung braucht deine Hilfe um zu wachsen. Wenn du einen Shader bereitstellen könntest wäre dies ein toller Dienst für die Community.

Wer einen Shader zur Shadersammlung hinzufügen möchte, findet am Ende dieses Seite eine [[#Vorlage|Vorlage]].

==Schwierigkeitsgrad==
Es ist nicht leicht einen Schwierigkeitsgrad für Shader anzugeben, trotzdem haben wir dies einmal versucht. Der Schwierigkeitsgrad kann zumindest für Einsteiger einen groben Hinweis geben was man sich vielleicht mal anschauen könnte.
{|{{Prettytable_B1}} style="margin-left:50px;"
| {{TableHead}} | {{ShaderLevel|1}}
| Der Shader ist für Einsteiger geeignet. Um den Shader herum wird keine zusätzliche Infrastruktur benötigt.
|-
| {{TableHead}} | {{ShaderLevel|2}}
| Der Shader ist für Einsteiger geeignet, benötigt aber etwas zusätzliche Infrastruktur. Etwa benötigt ein Post-Processing-Shader ein [[FBO|FrameBufferObject]], für [[Bumpmapping]] wird eine [[Normalmap]] benötigt.
|-
| {{TableHead}} | {{ShaderLevel|3}}
| Mittlerer Schwierigkeitsgrad. Der Shader ist etwas komplizierter und/oder benötigt viel zusätzliche Infrastruktur.
|-
| {{TableHead}} | {{ShaderLevel|4}}
| Hoher Schwierigkeitsgrad. Der Shader ist kompliziert und/oder verwendet intensiv Extensions.
|-
| {{TableHead}} | {{ShaderLevel|5}}
| Extremer Schwierigkeitsgrad...alles was es sonst noch gibt.
|}

==GLSL-Shader==
Die hier gelisteten Shader sind in Kategorien aufgeteilt. Weitere Kategorien dürfen bei Bedarf einfach ergänzt werden.

===Beleuchtung und Texturen===
Diese Kategorie umfasst alles vom einfachen Fixed-Function-Pipeline-Ersatz über PerPixel-Licht und Bumpmapping bis zu ShadowMaps. Der Shader-Einsteiger wird in dieser Kategorie sicherlich fündig.
{|{{Prettytable_B1}} width=100%
| {{TableHead}} | [[shader_verysimple|Verysimple]] von [[Benutzer:damadmax|damadmax]] {{ShaderLevel|1}}
| {{Table150R2}} style="text-align:center;" | (kein Bild vorhanden)
|-
| {{TableCell}} | Ein einfacher Shader, welcher eine Textur an Vertices bindet. Dieser Shader baut damit das Standardverhalten der festen Pipeline nach. {{ShaderLink|shader_verysimple}}
|-
| {{TableHead}} | [[shader_PerPixelLighting|Per Pixel-Beleuchtung]] von [[Benutzer:Ireyon|Ireyon]] {{ShaderLevel|1}}
| {{Table150R2}} | [[Bild:shader_ppl.png|150px|150px]]
|-
| {{TableCell}} | Shader, der Per Pixel beleuchtet. {{ShaderLink|shader_PerPixelLighting}}
|-
| {{TableHead}} | [[shader_PerPixel_Lighting2|Per Pixel-Beleuchtung2]] von [[Benutzer:Olee|Olee]] {{ShaderLevel|1}}
| {{Table150R2}} | [[Bild:PPLShader.jpg|150px|150px]]
|-
| {{TableCell}} | Beleuchtet Flächen nach Pixeln anstatt wie OpenGl-Licht je Vertex. Erlaubt unendlich weit entferntes Licht und beachtet [[glFog]]. {{ShaderLink|shader_PerPixel_Lighting2}}
|-
| {{TableHead}} | [[shader_Bumpmapping|BumpmappingShader]] von [[Benutzer:Bergmann89|Bergmann89]] {{ShaderLevel|2}}
| {{Table150R2}} | [[Bild:Bumpmapping.JPG|150px|150px]]
|-
| {{TableCell}} | BumpmappingShader auf der Basis des [[shader_PerPixelLighting|Per Pixel-Beleuchtung]]-Shaders {{ShaderLink|shader_Bumpmapping}}
|-
| {{TableHead}} | [[shader_ConeVolumeShadow|Kegelvolumen-Schatten ]] von [[Benutzer:Coolcat|Coolcat]] {{ShaderLevel|3}}
| {{Table150R2}} | [[Bild:shader_ConeVolumeShadow2.jpg|150px|150px]]
|-
| {{TableCell}} | Spezialshader für realistische Schatten einer Kugellichtquelle. Kugellichtquellen erzeugen im Gegensatz zu den üblichen Punktlichtquellen weiche Schatten. Dieser Ansatz ist im Vergleich extrem schnell, da er nur eine Erweiterung des gewöhnlichen Per-Pixel-Lighting darstellt. Allerdings funktioniert dieser Shader nur dann, wenn es sich bei sämtlichen Schatten werfenden Objekten in der Szene um Kugeln handelt. {{ShaderLink|shader_ConeVolumeShadow}}
|}

===Post-Processing===
Post-Processing-Shader zeichnen sich dadurch aus, dass sie auf die gesamte Szene angewendet werden nachdem diese bereits gerendert wurde. Üblicherweise wird die Szene zuerst mit einem [[FBO|FramebufferObject]] (FBO) in eine Textur gerendert. Anschließend wird diese Textur auf ein bildschirmfüllendes Quad gespannt und mit dem Post-Processing-Shader gerendert.
{|{{Prettytable_B1}} width=100%
| {{TableHead}} | [[shader_sepia|Sepia-Shader]] von [[Benutzer:Markus|Markus]] {{ShaderLevel|2}}
| {{Table150R2}} | [[Bild:shader_sepia_nachher.jpg|150px|150px]]
|-
| {{TableCell}} | Post-Processing-Shader, welcher einen Sepia-Farbfilter auf die Szene anwendet. {{ShaderLink|shader_sepia}}
|-
| {{TableHead}} | [[shader_radial_blur|Radial Blur]] von [[Benutzer:Markus|Markus]] {{ShaderLevel|2}}
| {{Table150R2}} | [[Bild:shader_radial_blur_nachher.jpg|150px|150px]]
|-
| {{TableCell}} | Post-Processing-Shader, welcher die Szene ausgehend von einem beliebigen Punkt verwischt. {{ShaderLink|shader_radial_blur}}
|-
| {{TableHead}} | [[shader_blur2|Blur-Shader]] von [[Benutzer:Skeptiker|Skeptiker]] und [[Benutzer:Coolcat|Coolcat]] {{ShaderLevel|3}}
| {{Table150R2}} | [[Bild:Shader_blur_seerose_blured_small.jpg|150px|150px]]
|-
| {{TableCell}} | Post-Processing-Shader, welcher die Szene insgesamt verwischt. Dieser Shader kann beispielsweise genutzt werden um einen Glow-Effekt zu erreichen. {{ShaderLink|shader_blur2}}
|-
| {{TableHead}} | [[shader_Stereoscopy|Stereoskopie]] von [[Benutzer:Joni|Joni]] {{ShaderLevel|2}}
| {{Table150R2}} | [[Bild:shader_stereo_preview.png|150px|150px]]
|-
| {{TableCell}} | Sammlung von Post-Processing-Shadern, welche ein linkes und ein rechtes Bild als Stereogramm mit verschiedenen Methoden (verschiedene Anaglyphen, Zeilenverschachtelung, ...) anzeigen. {{ShaderLink|shader_Stereoscopy}}
|}

===Geometrie===
Hier finden sich Shader die die Geometrie entweder komplett neu erzeugen oder stark verändern. Es muss nicht unbedingt Geometryshader oder Instancing sein, auch mit dem Vertexshader kann man schon viel anstellen. Ein klassisches Beispiel ist die Mesh-Animation.
{|{{Prettytable_B1}} width=100%
| {{TableHead}} | [[shader_Terrain_GPU4|Heightmap-Terrain]] von [[Benutzer:Coolcat|Coolcat]] {{ShaderLevel|3}}
| {{Table150R2}} | [[Bild:Terrain.jpg|150px|150px]]
|-
| {{TableCell}} | Shader für ein Heightmap-Terrain der ShaderModel 4.0 Features nutzt. Das Terrain wird zur Laufzeit fast vollständig aus der Heightmap generiert, was ordentlich Speicherplatz spart. Im Fragmentshader werden drei Texturlayer mit Hilfe einer Alphamap interpoliert {{ShaderLink|shader_Terrain_GPU4}}

'''Extensions:''' 
[[GL_EXT_gpu_shader4]]
|-
| {{TableHead}} | [[shader_Instancing|Instancing-Shader]] von [[Benutzer:Coolcat|Coolcat]] {{ShaderLevel|4}}
| {{Table150R2}} | [[Bild:shader_Instancing.jpg|150px|150px]]
|-
| {{TableCell}} | Dieser Shader zeigt die Benutzung von [[GL_ARB_draw_instanced]]. Ein häufiger Anwendungsfall ist das rendern vieler gleichartiger Objekte. Die Extension beschleunigt derartige Anwendungen, in dem die Anzahl der API-Aufrufe und die Menge redundanter Daten reduziert wird. {{ShaderLink|shader_Instancing}}

'''Extensions:''' 
[[GL_ARB_draw_instanced]] 
[[GL_EXT_gpu_shader4]] 
[[GL_EXT_texture_buffer_object]] 
[[GL_ARB_texture_float]]
|-
| {{TableHead}} | [[shader_tesselation|Tesselation-Shader]] von [[Benutzer:dj3hut1|dj3hut1]] {{ShaderLevel|4}}
| {{Table150R2}} | [[Bild:Tesselation_s.png|150px|150px]]
|-
| {{TableCell}} | Dieser Shader nutzt einen Geometry Shader um ein Dreieck zu tesselieren. {{ShaderLink|shader_tesselation}}

'''Extensions:''' 
[[GL_ARB_geometry_shader4]]
|-
| {{TableHead}} | [[shader_normal_debug|Normal Debugging-Shader]] von [[Benutzer:dj3hut1|dj3hut1]] {{ShaderLevel|4}}
| {{Table150R2}} | [[Bild:Normal_debug_s.png|113px|150px]]
|-
| {{TableCell}} | Nützlicher Shader um ohne viel Aufwand die Normalen eines Modells anzuzeigen. {{ShaderLink|shader_normal_debug}}

'''Extensions:''' 
[[GL_ARB_geometry_shader4]]
|}

===Partikel===
Natürlich kann man auch bei einem [[Partikelsystem]] Shader einsetzen. Mit etwas Geschick kann man die gesamte Berechnung sogar vollständig auf die Grafikkarte verlagern um die CPU zu entlasten.
{|{{Prettytable_B1}} width=100%
| {{TableHead}} | [[GLSL_Partikel_2|GPU Partikelsystem]] von [[Benutzer:Coolcat|Coolcat]] {{ShaderLevel|5}}
| {{Table150R2}} | [[Bild:Partikel-Gravitation.jpg|150px|150px]]
|-
| {{TableCell}} | Ein GPU-Partikelsystem welches insbesondere auf SM4 Features wie Geometryshader und Transform-Feedback setzt. So ist auch eine Partikel-Partikel-Interaktion mit über 200.000 Partikeln ist kein Problem. {{ShaderLink|GLSL_Partikel_2}}

'''Extensions:''' 
[[GL_EXT_geometry_shader4]] 
[[GL_NV_transform_feedback]] 
[[GL_EXT_gpu_shader4]] 
[[GL_EXT_texture_buffer_object]] 
[[GL_ARB_texture_float]] 
[[GL_EXT_texture_integer]]
|-
| {{TableHead}} | [[GLSL_Partikel|GPU Partikelsystem für alte Hardware]] von [[Benutzer:Oc2k1|Oc2k1]] {{ShaderLevel|5}}
| {{Table150R2}} style="text-align:center;" | (kein Bild vorhanden)
|-
| {{TableCell}} | Ebenfalls ein GPU-Partikelsystem, welches aber auf FramebufferObjects und Fragmentshader setzt. Damit sollte es auch auf älterer Hardware funktionieren. {{ShaderLink|GLSL_Partikel}}

'''Extensions:''' 
[[GL_ARB_texture_float]]
|}

===Sonstiges===
Hier kommt alles rein was sonst nirgendwo rein passt und eine neue Kategorie nicht lohnenswert ist.
{|{{Prettytable_B1}} width=100%
| {{TableHead}} | [[shader_game_of_life|Game of Life]] von [[Benutzer:dj3hut1|dj3hut1]] {{ShaderLevel|3}}
| {{Table150R2}} | [[Bild:Game_of_life_s.png|150px|150px]]
|-
| {{TableCell}} | Simuliert das altbekannte 'Game of Life' im Shader. {{ShaderLink|shader_game_of_life}}
|-
| {{TableHead}} | [[shader_Zufallsgenerator|Pseudozufallsgenerator]] von [[Benutzer:Coolcat|Coolcat]] {{ShaderLevel|4}}
| {{Table150R2}} | [[Bild:shader_Zufallsgenerator.png|150px|150px]]
|-
| {{TableCell}} | Generierung von Pseudozufallszahlen im Shader mit [[GL_EXT_gpu_shader4]]. Außerdem eine Beispielanwendung: Ein reproduzierbares pesudozufälliges Verwirbelfeld für ein GPU-Partikelsystem. {{ShaderLink|shader_Zufallsgenerator}}

'''Extensions:''' 
[[GL_EXT_gpu_shader4]]
|}

==Non-GLSL-Shader==
In diesem Abschnitt findet ihr Shader die mit einer anderen Technik als GLSL geschrieben wurden.

{|{{Prettytable_B1}} width=100%
| {{TableHead}} | [[shader_texturing(ARB)|Texturing (ARB)]] von [[Benutzer:dj3hut1|dj3hut1]] {{ShaderLevel|1}}
| {{Table150R2}} | [[Bild:Texarb_textured_s.png|166px|150px]]
|-
| {{TableCell}} | Demonstriert eine einfache Texturierung. {{ShaderLink|shader_texturing(ARB)}}
|-
| {{TableHead}} | [[shader_phong_per_pixel(ARB)|Phong per Pixel (ARB)]] von [[Benutzer:dj3hut1|dj3hut1]] {{ShaderLevel|1}}
| {{Table150R2}} | [[Bild:Phong_arb_s.png|150px|150px]]
|-
| {{TableCell}} | Per-Pixel-Beleuchtung. {{ShaderLink|shader_phong_per_pixel(ARB)}}
|-
| {{TableHead}} | [[shader_diffuse_bumpmapping(Cg)|Diffuse Bumpmapping (NVIDIA-Cg)]] von [[Benutzer:igel457|igel457]] {{ShaderLevel|2}}
| {{Table150R2}} | [[Bild:shader_diffuse_bumpmapping_cg.jpg|150px|150px]]
|-
| {{TableCell}} | Wendet diffuses Bumpmapping auf eine beliebige Oberfläche an. {{ShaderLink|shader_diffuse_bumpmapping(Cg)}}
|-
| {{TableHead}} | [[shader_surface_scattering(ARB)|Surface Scattering (ARB)]] von [[Benutzer:dj3hut1|dj3hut1]] {{ShaderLevel|3}}
| {{Table150R2}} | [[Bild:Scattering_s.jpg|150px|150px]]
|-
| {{TableCell}} | Der Shader bestimmt die Distanz, die Licht durch ein Material zurücklegt. Auf diese Weise wird die Lichtdurchlässigkeit bestimmt. {{ShaderLink|shader_surface_scattering(ARB)}}
|-
|}

==Vorlage==
Die Shadersammlung braucht deine Hilfe um zu wachsen. Wenn du einen Shader bereitstellen könntest wäre dies ein toller Dienst für die Community.

Folgende Schritte müssen gemacht werden um einen Shader einzutragen:
# Erstelle mit Hilfe der [[Shaderartikelvorlage]] einen neuen Artikel. Dazu den wiki-Code der Vorlage einfach kopieren und in den neuen Artikel einfügen. Der Artikelname sollte mit dem Präfix <tt>shader_</tt> beginnen, z.B. <tt>shader_Wasser2d</tt> für einen 2D Wassershader.
# Da Shader zu 90% optische Effekte bewirken, sollte (mindestens) ein aussagekräftiges Beispielbild im Shaderartikel hinterlegt werden. Eines der Bilder sollte dann auch hier in der Liste verlinkt werden.
# Füge deinen Shader in die Shadersammlung ein. Verwende dazu dieses Template: <tt> |-</tt> <tt> | <nowiki>{{TableHead}} | [[shader_Wasser2d|2D Wassershader]] von [[Benutzer:DeinName|DeinName]]</nowiki></tt> <tt> | <nowiki>{{Table150R2}} | [[Bild:Wassershader2D.jpg|150px|150px]]</nowiki></tt> <tt> |-</tt> <tt> | <nowiki>{{TableCell}}</nowiki> | Einige Sätze zur Beschreibung des Shaders. <nowiki>{{ShaderLink|shader_Wasser2d}}</nowiki></tt> <tt> </tt> <tt><nowiki>'''Extensions:''' </nowiki></tt> <tt>Liste von notwendigen Extensions.</tt> <tt> |-</tt>
# Keine Angst, es muss nicht alles auf Anhieb perfekt sein.

Falls du Fragen oder Probleme mit der Vorlage hast, im [[DGL-Chat]] oder [http://www.delphigl.com/forum/ Forum] hilft man immer gerne.

Datei:shader stereo preview.png

2010-03-11T14:35:07Z

Joni:

shader Stereoscopy

2010-03-11T14:16:00Z

Joni: Die Seite wurde neu angelegt: „=Stereoskopischer Post-Processing-Shader= Zurück zur Shadersammlung {|{{Prettytable_B1}} width=100% !width=60%|Beschreibung !width=20%|Autor !width=20%|Versi…“

=Stereoskopischer Post-Processing-Shader=
Zurück zur [[Shadersammlung]]
{|{{Prettytable_B1}} width=100%
!width=60%|Beschreibung
!width=20%|Autor
!width=20%|Version
|-
|Post-Processing-Shader für Stereoskopie
|Joni
|1.0
|}

==Bilder==
{|
|[[Bild:stereo_shader1.png|600px|verschiedene Stereoskopie-Verfahren]]
|}
''Oben: Half-Color Anaglyph; mitte: Horizontal Interlaced (funktioniert nur bei maximaler Bildauflösung); unten: Full-Color Anaglyph''

==Beschreibung==
Die hier vorgestellten Shader konvertieren mit verschiedenen Verfahren ein linkes und ein rechtes Eingabebild in ein stereoskopisches Bild. In dem folgenden Abschnitt werden die einzelnen Verfahren näher erläutert.
===Horizontal Interlaced===
Bei der zeilenverschachtelten Stereoskopie sind alle ungeraden Pixelzeilen für das linke Auge und alle geraden Pixelzeilen für das rechte Auge bestimmt. Verwendet wird dieses Verfahren u. A. von den Zalman- und den Hyundai-3D-Bildschirmen.
===Vertical Interlaced===
Analog zur zeilenverschachtelten Stereoskopie wird hier nach ungeraden und geraden Spalten sortiert. Verwendet wird dieses Verfahren u. A. für den Druck auf Linsenrasterkarten.
===Checkerboard===
Hier gehören jeweils die Pixel, die diagonal zueinander liegen, zu einem Auge. Die Aufteilung erinnert an ein Schachbrett, daher der Name. Verwendet wird das Verfahren u. A. von einigen Fernsehen von Samsung in Kombination mit einer Shutterbrille.
===Half-Color Anaglyphen===
Das Half-Color-Verfahren ist ein Anaglyphen-Verfahren für rot/cyan-Brillen, das im gegenüber dem True-Color-Anaglyphen-Verfahren, was auch im [[Tutorial_StereoSehen|Stereoskopie-Tutorial]] verwendet wird, einen nennenswerten Vorteil bei farbiger Szene hat. Bei dem True-Color-Verfahren wird für den roten Kanal des finalen Bildes der rote Kanal des linken Bildes genommen, was zu Konflikten bei roten Objekten in der Szene führt. Diese erscheinen dann auf dem linken Auge mit voller Helligkeit und auf dem rechten Auge schwarz. Das Half-Color-Verfahren verwendet daher für den roten Farbkanal des finalen Bildes nicht den roten Kanal des linken Bildes, sondern dessen Helligkeit, die wie bei Graustufen mit der folgenden Formel berechnet wird:
<source lang="glsl">luminance = 0.299*red + 0.587*green + 0.114*blue</source>
Der Nachteil dieses Verfahrens ist, dass die Farben etwas verfälscht werden.
===Optimized Anaglyphen===
Dieses Verfahren ähnelt dem Half-Color-Verfahren, ignoriert aber bei dem linken Bild den Rotanteil vollständig und berechnet den finalen roten Kanal folgendermaßen:
<source lang="glsl">red = 0.7*green + 0.3*blue</source>
Dieses Verfahren erstellt noch etwas ruhigere Bilder als das Half-Color-Verfahren, verfälscht die Farben aber auch stärker. Zusätzlich kann bei dem Verfahren noch Gammakorrektur auf den roten Kanal angewandt werden.
{|
[[Bild:anaglyph_problem.png|center|Die oben beschriebenen Verfahren angewandt auf ein rotes Objekt]]
|}

==Besondere Vorraussetzungen==
Um den Code sinnvoll zu benutzen, ist eine Anaglyphen-Brille oder ein stereoskopisches Gerät, das eins der o.g. Verfahren verwendet, nötig.

==Anmerkungen==
Für die Verwendung von Anaglyphen mit grün/magenta kann man die o.g. Verfahren entsprechend anpassen. Welches Verfahren sich dafür anbietet, ist zu testen, da der Autor keine solche Brille besitzt.

Das neu aufgekommene, patentierte ColorCode-Verfahren sieht zwar gelb/blauen Anaglyphen ähnlich, ist jedoch anders und nicht zu gelb/blau-Anaglyphen kompatibel. Da das Color-Code-Verfahren patentiert und nicht öffentlich bekannt ist, besteht leider keine Möglichkeit, es hier zu verwenden.

Für Shutterbrillen, Doppelprojektoren etc. ist man in OpenGL auf eine Treiberlösung angewiesen. Details dazu gibt es im [[Tutorial_StereoSehen|Tutorial StereoSehen]].

==Code==
Hier wird OpenGL 3.2 und GLSL-Version 1.5 verwendet, die Shader sollten jedoch problemlos mit jeder GLSL-Version funktionieren.
===Vertex Shader===
Da es sich um einen Post-Processing-Shader handelt, tut der Vertexshader nur das Nötigste: Er leitet Vertex- und Texturkoordinaten weiter.
<source lang="glsl">#version 150

in vec3 in_Position;
in vec2 in_TexCoord;
out vec2 ex_TexCoord;

void main(void)
{
gl_Position = vec4(in_Position, 1.0);
ex_TexCoord = in_TexCoord;
}</source>
===Horizontal Interlaced===
<source lang="glsl">#version 150

precision highp float;

in vec3 ex_Color;
in vec2 ex_TexCoord;
out vec4 out_Color;

uniform sampler2D left; //Linkes Bild
uniform sampler2D right; //Rechtes Bild

void main(void)
{
//Horizontal Interlaced
if (mod(trunc(gl_FragCoord.y), 2.0) < 0.5)
out_Color = texture2D(left, vec2(ex_TexCoord));
else
out_Color = texture2D(right, vec2(ex_TexCoord));
}</source>
===Vertical Interlaced===
<source lang="glsl">#version 150

precision highp float;

in vec3 ex_Color;
in vec2 ex_TexCoord;
out vec4 out_Color;

uniform sampler2D left;
uniform sampler2D right;

void main(void)
{
//Vertical Interlaced
if (mod(trunc(gl_FragCoord.x), 2.0) < 0.5)
out_Color = texture2D(left, vec2(ex_TexCoord));
else
out_Color = texture2D(right, vec2(ex_TexCoord));
}</source>
===Checkerboard===
<source lang="glsl">#version 150

precision highp float;

in vec3 ex_Color;
in vec2 ex_TexCoord;
out vec4 out_Color;

uniform sampler2D left;
uniform sampler2D right;

void main(void)
{
//Checkerboard
bool d1 = (mod(trunc(gl_FragCoord.x), 2.0) < 0.5);
bool d2 = (mod(trunc(gl_FragCoord.y), 2.0) < 0.5);
if (d1==d2)
out_Color = texture2D(left, vec2(ex_TexCoord));
else
out_Color = texture2D(right, vec2(ex_TexCoord));
}</source>
===Half-Color-Anaglyph===
<source lang="glsl">#version 150

precision highp float;

in vec3 ex_Color;
in vec2 ex_TexCoord;
out vec4 out_Color;

uniform sampler2D left;
uniform sampler2D right;

void main(void)
{
//Half-Color Anaglyphen
vec3 cleft = texture2D(left, vec2(ex_TexCoord)).xyz;
vec3 cright = texture2D(right, vec2(ex_TexCoord)).xyz;
out_Color.r = 0.299*cleft.r + 0.587*cleft.g + 0.114*cleft.b; //Half-Color
out_Color.g = cright.g;
out_Color.b = cright.b;
}
</source>
===Optimized-Anaglyph===
<source lang="glsl">#version 150

precision highp float;

in vec3 ex_Color;
in vec2 ex_TexCoord;
out vec4 out_Color;

uniform sampler2D left;
uniform sampler2D right;

void main(void)
{
//Half-Color Anaglyphen
vec3 cleft = texture2D(left, vec2(ex_TexCoord)).xyz;
vec3 cright = texture2D(right, vec2(ex_TexCoord)).xyz;
out_Color.r = 0.7*cleft.g + 0.3*cleft.b; //ohne Gammakorrektur
out_Color.r = pow(0.7*cleft.g + 0.3*cleft.b, 1.5); //mit Gammakorrektur
out_Color.g = cright.g;
out_Color.b = cright.b;
}
</source>

==Links==
http://www.3dtv.at/knowhow/AnaglyphComparison_en.aspx
==Siehe auch==
[[Tutorial_StereoSehen]]

Datei:anaglyph problem.png

2010-03-11T14:04:56Z

Joni: hat eine neue Version von „Datei:anaglyph problem.png“ hochgeladen

Verschiedene Anaglyphenmethoden bei einem roten Objekt

Datei:anaglyph problem.png

2010-03-11T13:28:42Z

Joni: Verschiedene Anaglyphenmethoden bei einem roten Objekt

Verschiedene Anaglyphenmethoden bei einem roten Objekt

Datei:stereo shader1.png

2010-03-11T13:25:08Z

Joni:

Datei:stereo shader1.jpg

2010-03-09T17:00:59Z

Joni: Verschiedene stereoskopische Verfahren in einem Bild

Verschiedene stereoskopische Verfahren in einem Bild