DGL Wiki - Benutzerbeiträge [de]

Shadersammlung

2010-01-06T14:49:38Z

Markus: Radial Blur Zusammenfassung verändert

Die DGL Shadersammlung soll euch helfen Shader für OpenGL zu finden.

=Organisation=
==Aufbau==
Für den Anfang wird die Shadersammlung nicht gegliedert. Mit wachsender Anzahl der verlinkten Shader wird sich dies ändern.
{{Hinweis|Die Shadersammlung braucht eure Hilfe um zu wachsen. Wenn ihr Shader bereitstellen könntet wäre dies ein toller Dienst für die Community. 
''The shader collection is still in an early phase. If you can publish one of your shaders here, this would be a great thing for the community.''}}

==Vorlage==
Falls ihr einen Shader bereitstellen wollt sind drei Dinge nötig:
# Kopiert die nachfolgende Vorlage ans Ende der Shaderliste und tragt die passenden Daten ein.
# Erstellt einen neuen Shaderartikel den ihr in der eingefügten Zeile verlinkt. Benutzt dazu die [[Shaderartikelvorlage]]. Shaderartikel müssen mit '''shader_''' benannt sein. ''z.B. shader_Wasser2d'' für einen 2D Wassershader.
# Da Shader zu 90% optische Effekte bewirken, sollte (mindestens) ein aussagekräftiges Beispielbild im Shaderartikel hinterlegt werden. Das Bild muss dann auch hier in der Liste verlinkt werden.

Fügt folgenden Code ans Ende der Shaderliste an:
!<nowiki>[[shader_HierNameEintragen]]</nowiki>
!HierNameEintragen
!Autorname
!Was macht der Shader.<nowiki> </nowiki>
''What does the shader do.''*
!<nowiki>[[Bild:Beispielbild.jpg|150px|150px]]</nowiki>

''* Die englische Beschreibung ist freiwillig. Hilft aber bestimmt den Shader zu verbreiten. Die deutsche Beschreibung ist Pflicht.''

Für euren neuen Shaderartikel sollte diese [[Shaderartikelvorlage]] benutzt werden. (Vorlage aufrufen, bearbeiten klicken, Alles kopieren und in euren neuen Shaderartikel einfügen.)

=Shader=
== ARB-Shader ==
{|{{Prettytable_B1}} width=100%
!width=20%|Link
!width=20%|Shadername
!width=20%|Autor
!width=40%|Kurzbeschreibung
!width=150px|Bild
|-
![[shader_surface_scattering(ARB)|shader_surface_scattering]]
!surface scattering
!dj3hut1
!Bestimmt die Distanz, die Licht durch ein Material zurücklegt.
 
''Calculates the distance of light through a material.''
![[Bild:Scattering_s.jpg|150px|150px]]
|-
![[shader_texturing(ARB)|shader_texturing]]
!texturing
!dj3hut1
!Demonstriert eine einfache Texturierung.
 
''Demonstrates a simple texturing.''
![[Bild:Texarb_textured_s.png|166px|150px]]
|-
![[shader_phong_per_pixel(ARB)|shader_phong_per_pixel]]
!phong lighting per pixel
!dj3hut1
!Per-Pixel-Beleuchtung.
 
''Per-pixel-lighting.''
![[Bild:Phong_arb_s.png|150px|150px]]

|}

== GLSL-Shader ==
{|{{Prettytable_B1}} width=100%
!width=20%|Link
!width=20%|Shadername
!width=20%|Autor
!width=40%|Kurzbeschreibung
!width=150px|Bild
|-
![[shader_verysimple]]
!verysimple
(standard texture binding)
!damadmax
!Ein einfacher Shader, welcher eine Textur an Vertices bindet. Dieser Shader baut damit das standard Texturierungsverhalten der fixen Pipeline nach. 
''A very simple shader. It only binds a texture on some vertices, thus this shader simulates the standard behavior of a part of the fixed pipeline.''
!''Kein Bild vorhanden''
|-
![[shader_sepia]]
!Sepia
!Markus
!Post-Processing-Shader, welcher einen Sepia-Farbfilter auf die Szene anwendet. 
''Post-Processing-Shader which applies a sepia color filter to the scene.''
![[Bild:shader_sepia_nachher.jpg|150px|150px]]
|-
![[shader_radial_blur]]
!Radial Blur
!Markus
!Post-Processing-Shader, welcher die Szene ausgehend von einem beliebigen Punkt verwischt. 
''Post-Processing-Shader which applies a radial blur to the scene.''
![[Bild:shader_radial_blur_nachher.jpg|150px|150px]]
|-
![[shader_blur2]]
!Blur-Shader
!Skeptiker/Coolcat
!Post-Processing-Shader, welcher die Szene insgesamt verwischt. 
''Post-Processing-Shader which applies a blur-effect to the scene.''
![[Bild:Shader_blur_seerose_blured_small.jpg|150px|150px]]
|-
![[shader_PerPixelLighting]]
!Per Pixel-Beleuchtung
!Ireyon
!Shader, der Per Pixel beleuchtet 
''Shader which calculates lighting per pixel''
![[Bild:shader_ppl.png|150px|150px]]
|-
![[shader_PerPixel_Lighting2]]
!Per-Pixel-Lighting Shader
!Olee
!Beleuchtet Flächen nach Pixeln anstatt wie OpenGl-Licht je Vertex. Erlaubt unendlich weit entferntes Licht und beachtet [[glFog]] 
''Iluminates faces per pixel istead of OpenGl-Lighting per Vertex. Allows infinite distance to the light and [[glFog]].''
![[Bild:PPLShader.jpg|150px|150px]]
|-
![[shader_Terrain_GPU4]]
!Heightmap-Terrain
!Coolcat
!Shader für ein Heightmap-Terrain, benutzt [[GL_EXT_gpu_shader4]] 
''Shader for Heightmap-Terrain, uses [[GL_EXT_gpu_shader4]]''
![[Bild:Terrain.jpg|150px|150px]]
|-
![[shader_Zufallsgenerator]]
!Pseudozufallsgenerator, Zufallswirbelfeld für Partikel
!Coolcat
!Pseudozufallszahlen im Shader mit [[GL_EXT_gpu_shader4]]. 
''Pseudo random numbers in the Shader using [[GL_EXT_gpu_shader4]] and a random turbulence field for particles.''
![[Bild:shader_Zufallsgenerator.png|150px|150px]]
|-
![[shader_game_of_life]]
!game of life
!dj3hut1
!Simuliert das altbekannte 'Game of Life'. 
''Simulates the well-known 'Game of Life'.''
![[Bild:Game_of_life_s.png|150px|150px]]
|-
![[shader_Instancing]]
!Instancing
!Coolcat
!Benutzung von [[GL_ARB_draw_instanced]] 
''Usage of [[GL_ARB_draw_instanced]]''
![[Bild:shader_Instancing.jpg|150px|150px]]
|}

=== Mit Geometry-Shader ===
{|{{Prettytable_B1}} width=100%
!width=20%|Link
!width=20%|Shadername
!width=20%|Autor
!width=40%|Kurzbeschreibung
!width=150px|Bild
|-
![[shader_tesselation]]
!tesselation
!dj3hut1
!Tesseliert ein Dreieck. 
''Tesselates a triangle.''
![[Bild:Tesselation_s.png|150px|150px]]
|-
![[shader_normal_debug]]
!normal debugging
!dj3hut1
!Nützlicher Shader um ohne viel Aufwand die Normalen eines Modells anzuzeigen. 
''Useful shader to show the normals of a model without much effort.''
![[Bild:Normal_debug_s.png|113px|150px]]
|}

== Cg-Shader ==
{|{{Prettytable_B1}} width=100%
!width=20%|Link
!width=20%|Shadername
!width=20%|Autor
!width=40%|Kurzbeschreibung
!width=150px|Bild
|-
![[shader_diffuse_bumpmapping(Cg)|diffuse_bumpmapping]]
!diffuse_bumpmapping
!igel457
!Wendet diffuses Bumpmapping auf eine beliebige Oberfläche an. 
''Applies diffuse bumpmapping to a surface.''
![[Bild:shader_diffuse_bumpmapping_cg.jpg|150px|150px]]
|}

Benutzer:Coolcat/Shadersammlung

2010-01-06T14:48:52Z

Markus: Radial Blur Zusammenfassung verändert

{{Hinweis|Dies ist ein Entwurf für eine übersichtlichere [[Shadersammlung]].}}

==Was sind Shader?==
Die traditionelle Funktionspipeline der OpenGL ist sehr beschränkt, neuere 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 wurde 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.

==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.

Falls du einen Shader bereitstellen möchtest lese bitte das Folgende kurze HowTo:
# Erstelle mit Hilfe der [[Shaderartikelvorlage]] einen neuen Artikel. 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.</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.

==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 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.
|}

==Shader==
===GLSL-Shader===
{|{{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_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_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_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. {{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}} | [[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}} | [[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]]
|-
| {{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_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]]
|}

===ARB-Shader===
{|{{Prettytable_B1}} width=100%
| {{TableHead}} | [[shader_surface_scattering(ARB)|Surface Scattering]] 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)}}
|-
| {{TableHead}} | [[shader_texturing(ARB)|Texturing]] 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]] von [[Benutzer:dj3hut1|dj3hut1]] {{ShaderLevel|1}}
| {{Table150R2}} | [[Bild:Phong_arb_s.png|150px|150px]]
|-
| {{TableCell}} | Per-Pixel-Beleuchtung. {{ShaderLink|shader_phong_per_pixel(ARB)}}
|}

===Cg-Shader===
{|{{Prettytable_B1}} width=100%
| {{TableHead}} | [[shader_diffuse_bumpmapping(Cg)|Diffuse Bumpmapping]] 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)}}
|}

shader radial blur

2010-01-06T14:48:09Z

Markus: Beschreibung angepasst

=Radial Blur=
Zurück zur [[Shadersammlung]]
{|{{Prettytable_B1}} width=100%
!width=60%|Beschreibung
!width=20%|Autor
!width=20%|Version
|-
|Post-Processing-Shader, welcher die Szene ausgehend von einem beliebigen Punkt verwischt.
|Markus
|1.1
|}

==Bilder==
{|
|[[Bild:shader_radial_blur_vorher.jpg|framed|Vorher]]
|-
|[[Bild:shader_radial_blur_nachher.jpg|framed|Nachher]]
|}

==Beschreibung==
Dieser Shader verwischt die Szene ausgehend vom Mittelpunkt des Bildes. 

Folgende Uniform-Variablen werden verwendet:
{|{{Prettytable_B1}}
!width=20%|Variable
!width=80%|Beschreibung
|-
|''radial_blur''
|ändert die Stärke des Blurs
|-
|''radial_bright''
|ändert die Stärke der Helligkeitsänderung
|-
|''radial_origin''
|ändert den Ausgangspunkt des Blurs
|-
|''radial_size''
|muss die Größe eines Texels der Textur der Szene haben bei einer Auflösung von 1280x1024 Pixeln: vec2(1.0 / 1280.0, 1 / 1024.0)
|}

Die ''Texture''-Variable muss nur geändert werden, wenn sich die Szenentextur nicht im ersten Texturslot befindet.
 
Wenn man einen Explosionseffekt wie im Bild weiter oben erreichen möchte, kann man ''radial_blur'' und ''radial_bright'' mit einer Sinusfunktion über mehrere Frames verändern.

==Besondere Vorraussetzungen==
Da es sich um einen Post-Processing-Shader handelt, muss die Szene zuvor in eine Textur gerendert werden. Hier bieten sich FrameBufferObjects an, welche jedoch
nicht von alten Grafikkarten unterstützt werden. Optional kann man auch glCopyTexSubImage2D verwenden. Um nun den Blur-Filter auf die Szene anzuwenden, muss man
die zuvor erstellte Textur der Szene binden. Danach wird der Shader aktiviert und ein Quad mit der Größe des Viewports gezeichnet.

==Code==
Vertex Shader
<source lang="glsl">
void main(void)
{
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
gl_FrontColor = gl_Color;
gl_TexCoord[0] = gl_MultiTexCoord0;
}
</source>

Fragment Shader
<source lang="glsl">
// RadialBlur - Shader

uniform sampler2D Texture; // scene texture
uniform vec2 radial_size; // texel size

uniform float radial_blur; // blur factor
uniform float radial_bright; // bright factor

uniform vec2 radial_origin; // blur origin

void main(void)
{
vec2 TexCoord = vec2(gl_TexCoord[0]);

vec4 SumColor = vec4(0.0, 0.0, 0.0, 0.0);
TexCoord += radial_size * 0.5 - radial_origin;

for (int i = 0; i < 12; i++)
{
float scale = 1.0 - radial_blur * (float(i) / 11.0);
SumColor += texture2D(Texture, TexCoord * scale + radial_origin);
}

gl_FragColor = SumColor / 12.0 * radial_bright;
}
</source>

shader radial blur

2010-01-06T14:47:09Z

Markus: Beschreibung angepasst

=Radial Blur=
Zurück zur [[Shadersammlung]]
{|{{Prettytable_B1}} width=100%
!width=60%|Beschreibung
!width=20%|Autor
!width=20%|Version
|-
|Post-Processing-Shader, welcher die Szene ausgehend vom einem beliebigen Punkt verwischt.
|Markus
|1.1
|}

==Bilder==
{|
|[[Bild:shader_radial_blur_vorher.jpg|framed|Vorher]]
|-
|[[Bild:shader_radial_blur_nachher.jpg|framed|Nachher]]
|}

==Beschreibung==
Dieser Shader verwischt die Szene ausgehend vom Mittelpunkt des Bildes. 

Folgende Uniform-Variablen werden verwendet:
{|{{Prettytable_B1}}
!width=20%|Variable
!width=80%|Beschreibung
|-
|''radial_blur''
|ändert die Stärke des Blurs
|-
|''radial_bright''
|ändert die Stärke der Helligkeitsänderung
|-
|''radial_origin''
|ändert den Ausgangspunkt des Blurs
|-
|''radial_size''
|muss die Größe eines Texels der Textur der Szene haben bei einer Auflösung von 1280x1024 Pixeln: vec2(1.0 / 1280.0, 1 / 1024.0)
|}

Die ''Texture''-Variable muss nur geändert werden, wenn sich die Szenentextur nicht im ersten Texturslot befindet.
 
Wenn man einen Explosionseffekt wie im Bild weiter oben erreichen möchte, kann man ''radial_blur'' und ''radial_bright'' mit einer Sinusfunktion über mehrere Frames verändern.

==Besondere Vorraussetzungen==
Da es sich um einen Post-Processing-Shader handelt, muss die Szene zuvor in eine Textur gerendert werden. Hier bieten sich FrameBufferObjects an, welche jedoch
nicht von alten Grafikkarten unterstützt werden. Optional kann man auch glCopyTexSubImage2D verwenden. Um nun den Blur-Filter auf die Szene anzuwenden, muss man
die zuvor erstellte Textur der Szene binden. Danach wird der Shader aktiviert und ein Quad mit der Größe des Viewports gezeichnet.

==Code==
Vertex Shader
<source lang="glsl">
void main(void)
{
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
gl_FrontColor = gl_Color;
gl_TexCoord[0] = gl_MultiTexCoord0;
}
</source>

Fragment Shader
<source lang="glsl">
// RadialBlur - Shader

uniform sampler2D Texture; // scene texture
uniform vec2 radial_size; // texel size

uniform float radial_blur; // blur factor
uniform float radial_bright; // bright factor

uniform vec2 radial_origin; // blur origin

void main(void)
{
vec2 TexCoord = vec2(gl_TexCoord[0]);

vec4 SumColor = vec4(0.0, 0.0, 0.0, 0.0);
TexCoord += radial_size * 0.5 - radial_origin;

for (int i = 0; i < 12; i++)
{
float scale = 1.0 - radial_blur * (float(i) / 11.0);
SumColor += texture2D(Texture, TexCoord * scale + radial_origin);
}

gl_FragColor = SumColor / 12.0 * radial_bright;
}
</source>

shader radial blur

2010-01-06T14:43:50Z

Markus:

=Radial Blur=
Zurück zur [[Shadersammlung]]
{|{{Prettytable_B1}} width=100%
!width=60%|Beschreibung
!width=20%|Autor
!width=20%|Version
|-
|Post-Processing-Shader, welcher die Szene ausgehend vom Mittelpunkt verwischt.
|Markus
|1.1
|}

==Bilder==
{|
|[[Bild:shader_radial_blur_vorher.jpg|framed|Vorher]]
|-
|[[Bild:shader_radial_blur_nachher.jpg|framed|Nachher]]
|}

==Beschreibung==
Dieser Shader verwischt die Szene ausgehend vom Mittelpunkt des Bildes. 

Folgende Uniform-Variablen werden verwendet:
{|{{Prettytable_B1}}
!width=20%|Variable
!width=80%|Beschreibung
|-
|''radial_blur''
|ändert die Stärke des Blurs
|-
|''radial_bright''
|ändert die Stärke der Helligkeitsänderung
|-
|''radial_origin''
|ändert den Ausgangspunkt des Blurs
|-
|''radial_size''
|muss die Größe eines Texels der Textur der Szene haben bei einer Auflösung von 1280x1024 Pixeln: vec2(1.0 / 1280.0, 1 / 1024.0)
|}

Die ''Texture''-Variable muss nur geändert werden, wenn sich die Szenentextur nicht im ersten Texturslot befindet.
 
Wenn man einen Explosionseffekt wie im Bild weiter oben erreichen möchte, kann man ''radial_blur'' und ''radial_bright'' mit einer Sinusfunktion über mehrere Frames verändern.

==Besondere Vorraussetzungen==
Da es sich um einen Post-Processing-Shader handelt, muss die Szene zuvor in eine Textur gerendert werden. Hier bieten sich FrameBufferObjects an, welche jedoch
nicht von alten Grafikkarten unterstützt werden. Optional kann man auch glCopyTexSubImage2D verwenden. Um nun den Blur-Filter auf die Szene anzuwenden, muss man
die zuvor erstellte Textur der Szene binden. Danach wird der Shader aktiviert und ein Quad mit der Größe des Viewports gezeichnet.

==Code==
Vertex Shader
<source lang="glsl">
void main(void)
{
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
gl_FrontColor = gl_Color;
gl_TexCoord[0] = gl_MultiTexCoord0;
}
</source>

Fragment Shader
<source lang="glsl">
// RadialBlur - Shader

uniform sampler2D Texture; // scene texture
uniform vec2 radial_size; // texel size

uniform float radial_blur; // blur factor
uniform float radial_bright; // bright factor

uniform vec2 radial_origin; // blur origin

void main(void)
{
vec2 TexCoord = vec2(gl_TexCoord[0]);

vec4 SumColor = vec4(0.0, 0.0, 0.0, 0.0);
TexCoord += radial_size * 0.5 - radial_origin;

for (int i = 0; i < 12; i++)
{
float scale = 1.0 - radial_blur * (float(i) / 11.0);
SumColor += texture2D(Texture, TexCoord * scale + radial_origin);
}

gl_FragColor = SumColor / 12.0 * radial_bright;
}
</source>

shader radial blur

2010-01-06T14:42:18Z

Markus: Neue Version

=Radial Blur=
Zurück zur [[Shadersammlung]]
{|{{Prettytable_B1}} width=100%
!width=60%|Beschreibung
!width=20%|Autor
!width=20%|Version
|-
|Post-Processing-Shader, welcher die Szene ausgehend vom Mittelpunkt verwischt.
|Markus
|1.1
|}

==Bilder==
{|
|[[Bild:shader_radial_blur_vorher.jpg|framed|Vorher]]
|-
|[[Bild:shader_radial_blur_nachher.jpg|framed|Nachher]]
|}

==Beschreibung==
Dieser Shader verwischt die Szene ausgehend vom Mittelpunkt des Bildes. 

Folgende Uniform-Variablen werden verwendet:
{|{{Prettytable_B1}}
!width=20%|Variable
!width=80%|Beschreibung
|-
|''radial_blur''
|ändert die Stärke des Blurs
|-
|''radial_bright''
|ändert die Stärke der Helligkeitsänderung
|-
|''radial_origin''
|ändert den Ausgangspunkt des Blurs
|-
|''radial_size''
|muss die Größe eines Texels der Textur der Szene haben bei einer Auflösung von 1280x1024 Pixeln: vec2(1.0 / 1280.0, 1 / 1024.0)
|}

Die ''Texture''-Variable muss nur geändert werden, wenn sich die Szenentextur nicht im ersten Texturslot befindet.
 
Wenn man einen Explosionseffekt wie im Bild weiter oben erreichen möchte, kann man ''radial_blur'' und ''radial_bright'' mit einer Sinusfunktion über mehrere Frames verändern.

==Besondere Vorraussetzungen==
Da es sich um einen Post-Processing-Shader handelt, muss die Szene zuvor in eine Textur gerendert werden. Hier bieten sich FrameBufferObjects an, welche jedoch
nicht von alten Grafikkarten unterstützt werden. Optional kann man auch glCopyTexSubImage2D verwenden. Um nun den Farbfilter auf die Szene anzuwenden, muss man
die zuvor erstellte Textur binden (die Texturstufe muss dem Shader normalerweise nicht mitgeteilt werden, da TMU0 standard ist). Danach wird der Shader aktiviert und ein Quad
mit der Größe des Viewports gezeichnet.

==Code==
Vertex Shader
<source lang="glsl">
void main(void)
{
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
gl_FrontColor = gl_Color;
gl_TexCoord[0] = gl_MultiTexCoord0;
}
</source>

Fragment Shader
<source lang="glsl">
// RadialBlur - Shader

uniform sampler2D Texture; // scene texture
uniform vec2 radial_size; // texel size

uniform float radial_blur; // blur factor
uniform float radial_bright; // bright factor

uniform vec2 radial_origin; // blur origin

void main(void)
{
vec2 TexCoord = vec2(gl_TexCoord[0]);

vec4 SumColor = vec4(0.0, 0.0, 0.0, 0.0);
TexCoord += radial_size * 0.5 - radial_origin;

for (int i = 0; i < 12; i++)
{
float scale = 1.0 - radial_blur * (float(i) / 11.0);
SumColor += texture2D(Texture, TexCoord * scale + radial_origin);
}

gl_FragColor = SumColor / 12.0 * radial_bright;
}
</source>

shader radial blur

2010-01-06T14:38:36Z

Markus:

=Radial Blur=
Zurück zur [[Shadersammlung]]
{|{{Prettytable_B1}} width=100%
!width=60%|Beschreibung
!width=20%|Autor
!width=20%|Version
|-
|Post-Processing-Shader, welcher die Szene ausgehend vom Mittelpunkt verwischt.
|Markus
|1.1
|}

==Bilder==
{|
|[[Bild:shader_radial_blur_vorher.jpg|framed|Vorher]]
|-
|[[Bild:shader_radial_blur_nachher.jpg|framed|Nachher]]
|}

==Beschreibung==
Dieser Shader verwischt die Szene ausgehend vom Mittelpunkt des Bildes. 

Folgende Uniform-Variablen werden verwendet:

{|{{Prettytable_B1}}
!width=20%|Variable
!width=80%|Beschreibung
|-
|''radial_blur''
|ändert die Stärke des Blurs
|-
|''radial_bright''
|ändert die Stärke der Helligkeitsänderung
|-
|''radial_origin''
|ändert den Ausgangspunkt des Blurs
|-
|''radial_size''
|muss die Größe eines Texels der Textur der Szene haben bei einer Auflösung von 1280x1024 Pixeln: vec2(1.0 / 1280.0, 1 / 1024.0)
|}

Die ''Texture'' Variable muss nur geändert werden, wenn sich die Szenentextur nicht im ersten Texturslot befindet.

==Besondere Vorraussetzungen==
Da es sich um einen Post-Processing-Shader handelt, muss die Szene zuvor in eine Textur gerendert werden. Hier bieten sich FrameBufferObjects an, welche jedoch
nicht von alten Grafikkarten unterstützt werden. Optional kann man auch glCopyTexSubImage2D verwenden. Um nun den Farbfilter auf die Szene anzuwenden, muss man
die zuvor erstellte Textur binden (die Texturstufe muss dem Shader normalerweise nicht mitgeteilt werden, da TMU0 standard ist). Danach wird der Shader aktiviert und ein Quad
mit der Größe des Viewports gezeichnet.

==Code==
Vertex Shader
<source lang="glsl">
void main(void)
{
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
gl_FrontColor = gl_Color;
gl_TexCoord[0] = gl_MultiTexCoord0;
}
</source>

Fragment Shader
<source lang="glsl">
// RadialBlur - Shader

uniform sampler2D Texture; // scene texture
uniform vec2 radial_size; // texel size

uniform float radial_blur; // blur factor
uniform float radial_bright; // bright factor

uniform vec2 radial_origin; // blur origin

void main(void)
{
vec2 TexCoord = vec2(gl_TexCoord[0]);

vec4 SumColor = vec4(0.0, 0.0, 0.0, 0.0);
TexCoord += radial_size * 0.5 - radial_origin;

for (int i = 0; i < 12; i++)
{
float scale = 1.0 - radial_blur * (float(i) / 11.0);
SumColor += texture2D(Texture, TexCoord * scale + radial_origin);
}

gl_FragColor = SumColor / 12.0 * radial_bright;
}
</source>

shader radial blur

2010-01-06T14:37:52Z

Markus:

=Radial Blur=
Zurück zur [[Shadersammlung]]
{|{{Prettytable_B1}} width=100%
!width=60%|Beschreibung
!width=20%|Autor
!width=20%|Version
|-
|Post-Processing-Shader, welcher die Szene ausgehend vom Mittelpunkt verwischt.
|Markus
|1.1
|}

==Bilder==
{|
|[[Bild:shader_radial_blur_vorher.jpg|framed|Vorher]]
|-
|[[Bild:shader_radial_blur_nachher.jpg|framed|Nachher]]
|}

==Beschreibung==
Dieser Shader verwischt die Szene ausgehend vom Mittelpunkt des Bildes.

Folgende Uniform-Variablen werden verwendet:

{|{{Prettytable_B1}}
!width=20%|Variable
!width=80%|Beschreibung
|-
|''radial_blur''
|ändert die Stärke des Blurs
|-
|''radial_bright''
|ändert die Stärke der Helligkeitsänderung
|-
|''radial_origin''
|ändert den Ausgangspunkt des Blurs
|-
|''radial_size''
|muss die Größe eines Texels der Textur der Szene haben bei einer Auflösung von 1280x1024 Pixeln: vec2(1.0 / 1280.0, 1 / 1024.0)
|}

Die ''Texture'' Variable muss nur geändert werden, wenn sich die Szenentextur nicht im ersten Texturslot befindet.

==Besondere Vorraussetzungen==
Da es sich um einen Post-Processing-Shader handelt, muss die Szene zuvor in eine Textur gerendert werden. Hier bieten sich FrameBufferObjects an, welche jedoch
nicht von alten Grafikkarten unterstützt werden. Optional kann man auch glCopyTexSubImage2D verwenden. Um nun den Farbfilter auf die Szene anzuwenden, muss man
die zuvor erstellte Textur binden (die Texturstufe muss dem Shader normalerweise nicht mitgeteilt werden, da TMU0 standard ist). Danach wird der Shader aktiviert und ein Quad
mit der Größe des Viewports gezeichnet.

==Code==
Vertex Shader
<source lang="glsl">
void main(void)
{
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
gl_FrontColor = gl_Color;
gl_TexCoord[0] = gl_MultiTexCoord0;
}
</source>

Fragment Shader
<source lang="glsl">
// RadialBlur - Shader

uniform sampler2D Texture; // scene texture
uniform vec2 radial_size; // texel size

uniform float radial_blur; // blur factor
uniform float radial_bright; // bright factor

uniform vec2 radial_origin; // blur origin

void main(void)
{
vec2 TexCoord = vec2(gl_TexCoord[0]);

vec4 SumColor = vec4(0.0, 0.0, 0.0, 0.0);
TexCoord += radial_size * 0.5 - radial_origin;

for (int i = 0; i < 12; i++)
{
float scale = 1.0 - radial_blur * (float(i) / 11.0);
SumColor += texture2D(Texture, TexCoord * scale + radial_origin);
}

gl_FragColor = SumColor / 12.0 * radial_bright;
}
</source>

shader radial blur

2010-01-06T14:35:27Z

Markus:

=Radial Blur=
Zurück zur [[Shadersammlung]]
{|{{Prettytable_B1}} width=100%
!width=60%|Beschreibung
!width=20%|Autor
!width=20%|Version
|-
|Post-Processing-Shader, welcher die Szene ausgehend vom Mittelpunkt verwischt.
|Markus
|1.1
|}

==Bilder==
{|
|[[Bild:shader_radial_blur_vorher.jpg|framed|Vorher]]
|-
|[[Bild:shader_radial_blur_nachher.jpg|framed|Nachher]]
|}

==Beschreibung==
Dieser Shader verwischt die Szene ausgehend vom Mittelpunkt des Bildes.

''radial_blur''   ändert die Stärke des Blurs. 
''radial_bright'' ändert die Stärke der Helligkeitsänderung. 
''radial_origin'' ändert den Ausgangspunkt des Blurs. 
''radial_size''   muss die Größe eines Texels der Textur der Szene haben. (bei einer Auflösung von 1280x1024 Pixeln: vec2(1.0 / 1280.0, 1 / 1024.0))

{|{{Prettytable_B1}}
!width=20%|Variable
!width=80%|Beschreibung
|-
|''radial_blur''
|ändert die Stärke des Blurs
|-
|''radial_bright''
|ändert die Stärke der Helligkeitsänderung
|-
|''radial_origin''
|ändert den Ausgangspunkt des Blurs
|-
|''radial_size''
|muss die Größe eines Texels der Textur der Szene haben bei einer Auflösung von 1280x1024 Pixeln: vec2(1.0 / 1280.0, 1 / 1024.0)
|}

==Besondere Vorraussetzungen==
Da es sich um einen Post-Processing-Shader handelt, muss die Szene zuvor in eine Textur gerendert werden. Hier bieten sich FrameBufferObjects an, welche jedoch
nicht von alten Grafikkarten unterstützt werden. Optional kann man auch glCopyTexSubImage2D verwenden. Um nun den Farbfilter auf die Szene anzuwenden, muss man
die zuvor erstellte Textur binden (die Texturstufe muss dem Shader normalerweise nicht mitgeteilt werden, da TMU0 standard ist). Danach wird der Shader aktiviert und ein Quad
mit der Größe des Viewports gezeichnet.

==Code==
Vertex Shader
<source lang="glsl">
void main(void)
{
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
gl_FrontColor = gl_Color;
gl_TexCoord[0] = gl_MultiTexCoord0;
}
</source>

Fragment Shader
<source lang="glsl">
// RadialBlur - Shader

uniform sampler2D Texture; // scene texture
uniform vec2 radial_size; // texel size

uniform float radial_blur; // blur factor
uniform float radial_bright; // bright factor

uniform vec2 radial_origin; // blur origin

void main(void)
{
vec2 TexCoord = vec2(gl_TexCoord[0]);

vec4 SumColor = vec4(0.0, 0.0, 0.0, 0.0);
TexCoord += radial_size * 0.5 - radial_origin;

for (int i = 0; i < 12; i++)
{
float scale = 1.0 - radial_blur * (float(i) / 11.0);
SumColor += texture2D(Texture, TexCoord * scale + radial_origin);
}

gl_FragColor = SumColor / 12.0 * radial_bright;
}
</source>

Datei:shader radial blur nachher.jpg

2010-01-06T13:55:42Z

Markus: hat eine neue Version von „Datei:shader radial blur nachher.jpg“ hochgeladen: Neuere Version

Datei:shader radial blur vorher.jpg

2010-01-06T13:54:38Z

Markus: hat eine neue Version von „Datei:shader radial blur vorher.jpg“ hochgeladen: Neuere Version

Datei:shader radial blur nachher.jpg

2008-11-13T15:43:06Z

Markus:

Datei:shader radial blur vorher.jpg

2008-11-13T15:42:48Z

Markus:

shader radial blur

2008-11-13T15:29:54Z

Markus:

=Radial Blur=
Zurück zur [[Shadersammlung]]
{|{{Prettytable_B1}} width=100%
!width=60%|Beschreibung
!width=20%|Autor
!width=20%|Version
|-
|Post-Processing-Shader, welcher die Szene ausgehend vom Mittelpunkt verwischt.
|Markus
|1.0
|}

==Bilder==
{|
|[[Bild:shader_radial_blur_vorher.jpg|framed|Vorher]]
|-
|[[Bild:shader_radial_blur_nachher.jpg|framed|Nachher]]
|}

==Beschreibung==
Dieser Shader verwischt die Szene ausgehend vom Mittelpunkt des Bildes.

''BlurFactor'' ändert die Stärke des Blurs. 
''BrightFactor'' ändert die Stärke der Helligkeitsänderung. 
''Origin'' ändert den Ausgangspunkt des Blurs. 
''Size'' muss die Größe eines Texels haben. (bei 1600x1200: vec2(1 / 1600, 1 / 1200))

==Besondere Vorraussetzungen==
Da es sich um einen Post-Processing-Shader handelt, muss die Szene zuvor in eine Textur gerendert werden. Hier bieten sich FrameBufferObjects an, welche jedoch
nicht von alten Grafikkarten unterstützt werden. Optional kann man auch glCopyTexSubImage2D verwenden. Um nun den Farbfilter auf die Szene anzuwenden, muss man
die zuvor erstellte Textur binden (die Texturstufe muss dem Shader normalerweise nicht mitgeteilt werden, da TMU0 standard ist). Danach wird der Shader aktiviert und ein Quad
mit der Größe des Viewports gezeichnet.

==Code==
Vertex Shader
<cpp>
void main(void)
{
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
gl_FrontColor = gl_Color;
gl_TexCoord[0] = gl_MultiTexCoord0;
}
</cpp>

Fragment Shader
<cpp>
// radial blur

uniform sampler2D Texture;

//texel size
uniform vec2 Size;

void main(void)
{
float BlurFactor = 0.05;
float BrightFactor = 1.2;
vec2 Origin = vec2(0.5, 0.5);

vec2 TexCoord = vec2(gl_TexCoord[0]);

vec4 SumColor = vec4(0.0, 0.0, 0.0, 0.0);
TexCoord += Size * 0.5 - Origin;

for (int i = 0; i < 12; i++)
{
float scale = 1.0 - BlurFactor * (float(i) / 11.0);
SumColor += texture2D(Texture, TexCoord * scale + Origin);
}

gl_FragColor = SumColor / 12.0 * BrightFactor;
}
</cpp>

shader radial blur

2008-11-13T15:29:05Z

Markus: Die Seite wurde neu angelegt: =Radial Blur= Zurück zur Shadersammlung {|{{Prettytable_B1}} width=100% !width=60%|Beschreibung !width=20%|Autor !width=20%|Version |- |Post-Processing-Shader, wel...

=Radial Blur=
Zurück zur [[Shadersammlung]]
{|{{Prettytable_B1}} width=100%
!width=60%|Beschreibung
!width=20%|Autor
!width=20%|Version
|-
|Post-Processing-Shader, welcher die Szene ausgehend vom Mittelpunkt verwischt.
|Markus
|1.0
|}

==Bilder==
{|
|[[Bild:shader_radial_blur_vorher.jpg|framed|Vorher]]
|-
|[[Bild:shader_radial_blur_nachher.jpg|framed|Nachher]]
|}

==Beschreibung==
Dieser Shader verwischt die Szene ausgehend vom Mittelpunkt des Bildes.

''BlurFactor'' ändert die Stärke des Blurs.
''BrightFactor'' ändert die Stärke der Helligkeitsänderung.
''Origin'' ändert den Ausgangspunkt des Blurs.
''Size'' muss die Größe eines Texels haben. (bei 1600x1200: vec2(1 / 1600, 1 / 1200))

==Besondere Vorraussetzungen==
Da es sich um einen Post-Processing-Shader handelt, muss die Szene zuvor in eine Textur gerendert werden. Hier bieten sich FrameBufferObjects an, welche jedoch
nicht von alten Grafikkarten unterstützt werden. Optional kann man auch glCopyTexSubImage2D verwenden. Um nun den Farbfilter auf die Szene anzuwenden, muss man
die zuvor erstellte Textur binden (die Texturstufe muss dem Shader normalerweise nicht mitgeteilt werden, da TMU0 standard ist). Danach wird der Shader aktiviert und ein Quad
mit der Größe des Viewports gezeichnet.

==Code==
Vertex Shader
<cpp>
void main(void)
{
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
gl_FrontColor = gl_Color;
gl_TexCoord[0] = gl_MultiTexCoord0;
}
</cpp>

Fragment Shader
<cpp>
// radial blur

uniform sampler2D Texture;

//texel size
uniform vec2 Size;

void main(void)
{
float BlurFactor = 0.05;
float BrightFactor = 1.2;
vec2 Origin = vec2(0.5, 0.5);

vec2 TexCoord = vec2(gl_TexCoord[0]);

vec4 SumColor = vec4(0.0, 0.0, 0.0, 0.0);
TexCoord += Size * 0.5 - Origin;

for (int i = 0; i < 12; i++)
{
float scale = 1.0 - BlurFactor * (float(i) / 11.0);
SumColor += texture2D(Texture, TexCoord * scale + Origin);
}

gl_FragColor = SumColor / 12.0 * BrightFactor;
}
</cpp>

Shadersammlung

2008-11-13T15:20:32Z

Markus:

Die DGL Shadersammlung soll euch helfen Shader für OpenGL zu finden.

=Organisation=
==Aufbau==
Für den Anfang wird die Shadersammlung nicht gegliedert. Mit wachsender Anzahl der verlinkten Shader wird sich dies ändern.
==Vorlage==
Falls ihr einen Shader bereitstellen wollt sind drei Dinge nötig:
# Kopiert die nachfolgende Vorlage ans Ende der Shaderliste und tragt die passenden Daten ein.
# Erstellt einen neuen Shaderartikel den ihr in der eingefügten Zeile verlinkt. Benutzt dazu die [[Shaderartikelvorlage]]. Shaderartikel müssen mit '''shader_''' benannt sein. ''z.B. shader_Wasser2d'' für einen 2D Wassershader.
# Da Shader zu 90% optische Effekte bewirken, sollte (mindestens) ein aussagekräftiges Beispielbild im Shaderartikel hinterlegt werden. Das Bild muss dann auch hier in der Liste verlinkt werden.

Fügt folgenden Code ans Ende der Shaderliste an:
!<nowiki>[[shader_HierNameEintragen]]</nowiki>
!HierNameEintragen
!Autorname
!Was macht der Shader.<nowiki> </nowiki>
''What does the shader do.''*
!<nowiki>[[Bild:Beispielbild.jpg|150px|150px]]</nowiki>

''* Die englische Beschreibung ist freiwillig. Hilft aber bestimmt den Shader zu verbreiten. Die deutsche Beschreibung ist Pflicht.''

Für euren neuen Shaderartikel sollte diese [[Shaderartikelvorlage]] benutzt werden. (Vorlage aufrufen, bearbeiten klicken, Alles kopieren und in euren neuen Shaderartikel einfügen.)

=Shader=
== ARB-Shader ==
{|{{Prettytable_B1}} width=100%
!width=20%|Link
!width=20%|Shadername
!width=20%|Autor
!width=40%|Kurzbeschreibung
!width=150px|Bild
|-
![[shader_surface_scattering(ARB)|shader_surface_scattering]]
!surface scattering
!dj3hut1
!Bestimmt die Distanz, die Licht durch ein Material zurücklegt.
 
''Calculates the distance of light through a material.''
![[Bild:Scattering_s.jpg|144px|150px]]
|}
== GLSL-Shader ==
{|{{Prettytable_B1}} width=100%
!width=20%|Link
!width=20%|Shadername
!width=20%|Autor
!width=40%|Kurzbeschreibung
!width=150px|Bild
|-
![[shader_verysimple]]
!verysimple
(standard texture binding)
!damadmax
!Ein einfacher Shader, welcher eine Textur an Vertices bindet. Dieser Shader baut damit das standard Texturierungsverhalten der fixen Pipeline nach. 
''A very simple shader. It only binds a texture on some vertices, thus this shader simulates the standard behavior of a part of the fixed pipeline.''
!''Kein Bild vorhanden''
|-
![[shader_sepia]]
!Sepia
!Markus
!Post-Processing-Shader, welcher einen Sepia-Farbfilter auf die Szene anwendet. 
''Post-Processing-Shader which applies a sepia color filter to the scene.''
![[Bild:shader_sepia_nachher.jpg|150px|150px]]
|-
![[shader_radial_blur]]
!Radial Blur
!Markus
!Post-Processing-Shader, welcher die Szene ausgehend vom Mittelpunkt verwischt. 
''Post-Processing-Shader which applies a radial blur to the scene.''
![[Bild:shader_radial_blur_nachher.jpg|150px|150px]]
|}

== Cg-Shader ==
{|{{Prettytable_B1}} width=100%
!width=20%|Link
!width=20%|Shadername
!width=20%|Autor
!width=40%|Kurzbeschreibung
!width=150px|Bild
|-
![[shader_diffuse_bumpmapping(Cg)|diffuse_bumpmapping]]
!diffuse_bumpmapping
!igel457
!Wendet diffuses Bumpmapping auf eine beliebige Oberfläche an. 
''Applies diffuse bumpmapping to a surface.''
![[Bild:shader_diffuse_bumpmapping_cg.jpg|150px|150px]]
|}

Shadersammlung

2008-11-13T15:20:06Z

Markus:

Die DGL Shadersammlung soll euch helfen Shader für OpenGL zu finden.

=Organisation=
==Aufbau==
Für den Anfang wird die Shadersammlung nicht gegliedert. Mit wachsender Anzahl der verlinkten Shader wird sich dies ändern.
==Vorlage==
Falls ihr einen Shader bereitstellen wollt sind drei Dinge nötig:
# Kopiert die nachfolgende Vorlage ans Ende der Shaderliste und tragt die passenden Daten ein.
# Erstellt einen neuen Shaderartikel den ihr in der eingefügten Zeile verlinkt. Benutzt dazu die [[Shaderartikelvorlage]]. Shaderartikel müssen mit '''shader_''' benannt sein. ''z.B. shader_Wasser2d'' für einen 2D Wassershader.
# Da Shader zu 90% optische Effekte bewirken, sollte (mindestens) ein aussagekräftiges Beispielbild im Shaderartikel hinterlegt werden. Das Bild muss dann auch hier in der Liste verlinkt werden.

Fügt folgenden Code ans Ende der Shaderliste an:
!<nowiki>[[shader_HierNameEintragen]]</nowiki>
!HierNameEintragen
!Autorname
!Was macht der Shader.<nowiki> </nowiki>
''What does the shader do.''*
!<nowiki>[[Bild:Beispielbild.jpg|150px|150px]]</nowiki>

''* Die englische Beschreibung ist freiwillig. Hilft aber bestimmt den Shader zu verbreiten. Die deutsche Beschreibung ist Pflicht.''

Für euren neuen Shaderartikel sollte diese [[Shaderartikelvorlage]] benutzt werden. (Vorlage aufrufen, bearbeiten klicken, Alles kopieren und in euren neuen Shaderartikel einfügen.)

=Shader=
== ARB-Shader ==
{|{{Prettytable_B1}} width=100%
!width=20%|Link
!width=20%|Shadername
!width=20%|Autor
!width=40%|Kurzbeschreibung
!width=150px|Bild
|-
![[shader_surface_scattering(ARB)|shader_surface_scattering]]
!surface scattering
!dj3hut1
!Bestimmt die Distanz, die Licht durch ein Material zurücklegt.
 
''Calculates the distance of light through a material.''
![[Bild:Scattering_s.jpg|144px|150px]]
|}
== GLSL-Shader ==
{|{{Prettytable_B1}} width=100%
!width=20%|Link
!width=20%|Shadername
!width=20%|Autor
!width=40%|Kurzbeschreibung
!width=150px|Bild
|-
![[shader_verysimple]]
!verysimple
(standard texture binding)
!damadmax
!Ein einfacher Shader, welcher eine Textur an Vertices bindet. Dieser Shader baut damit das standard Texturierungsverhalten der fixen Pipeline nach. 
''A very simple shader. It only binds a texture on some vertices, thus this shader simulates the standard behavior of a part of the fixed pipeline.''
!''Kein Bild vorhanden''
|-
![[shader_sepia]]
!Sepia
!Markus
!Post-Processing-Shader, welcher einen Sepia-Farbfilter auf die Szene anwendet. 
''Post-Processing-Shader which applies a sepia color filter to the scene.''
![[Bild:shader_sepia_nachher.jpg|150px|150px]]
|-
![[shader_radial_blur]]
!Radial Blur
!Markus
!Post-Processing-Shader, welcher die Szene ausgehend vom Mittelpunkt verwischt. 
''Post-Processing-Shader which applies a radial blur to the scene.''
![[Bild:shader_radial_blur_nachher.jpg|150px|150px]]

== Cg-Shader ==
{|{{Prettytable_B1}} width=100%
!width=20%|Link
!width=20%|Shadername
!width=20%|Autor
!width=40%|Kurzbeschreibung
!width=150px|Bild
|-
![[shader_diffuse_bumpmapping(Cg)|diffuse_bumpmapping]]
!diffuse_bumpmapping
!igel457
!Wendet diffuses Bumpmapping auf eine beliebige Oberfläche an. 
''Applies diffuse bumpmapping to a surface.''
![[Bild:shader_diffuse_bumpmapping_cg.jpg|150px|150px]]
|}

Datei:shader sepia nachher.jpg

2008-11-07T23:30:21Z

Markus:

Datei:shader sepia vorher.jpg

2008-11-07T23:28:39Z

Markus: hat eine neue Version von „Bild:shader sepia vorher.jpg“ hochgeladen

Datei:shader sepia vorher.jpg

2008-11-07T23:26:08Z

Markus:

shader sepia

2008-11-07T23:23:55Z

Markus: Die Seite wurde neu angelegt: =Sepia= Zurück zur Shadersammlung {|{{Prettytable_B1}} width=100% !width=60%|Beschreibung !width=20%|Autor !width=20%|Version |- |Post-Processing-Shader, welcher e...

=Sepia=
Zurück zur [[Shadersammlung]]
{|{{Prettytable_B1}} width=100%
!width=60%|Beschreibung
!width=20%|Autor
!width=20%|Version
|-
|Post-Processing-Shader, welcher einen Sepia-Farbfilter auf die Szene anwendet.
|Markus
|1.0
|}

==Bilder==
{|
|[[Bild:shader_sepia_vorher.jpg|framed|Vorher]]
|-
|[[Bild:shader_sepia_nachher.jpg|framed|Nachher]]
|}

==Beschreibung==
Dieser Shader wendet einen Sepia-Farbfilter auf die Szene an. Dadurch wird das Bild in einem gelblich-bräunlichen Farbton angezeigt.

==Besondere Vorraussetzungen==
Da es sich um einen Post-Processing-Shader handelt, muss die Szene zuvor in eine Textur gerendert werden. Hier bieten sich FrameBufferObjects an, welche jedoch
nicht von alten Grafikkarten unterstützt werden. Optional kann man auch glCopyTexSubImage2D verwenden. Um nun den Farbfilter auf die Szene anzuwenden, muss man
die zuvor erstellte Textur binden (die Texturstufe muss dem Shader normalerweise nicht mitgeteilt werden, da TMU0 standard ist). Danach wird der Shader aktiviert und ein Quad
mit der Größe des Viewports gezeichnet.

==Code==
Vertex Shader
<cpp>
void main(void)
{
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
gl_FrontColor = gl_Color;
gl_TexCoord[0] = gl_MultiTexCoord0;
}
</cpp>

Fragment Shader
<cpp>
// scene texture
uniform sampler2D Texture;

void main(void)
{
// Sepia colors
vec4 Sepia1 = vec4( 0.2, 0.05, 0.0, 1.0 );
vec4 Sepia2 = vec4( 1.0, 0.9, 0.5, 1.0 );

vec4 Color = texture2D(Texture, vec2(gl_TexCoord[0]));

float SepiaMix = dot(vec3(0.3, 0.59, 0.11), vec3(Color));
Color = mix(Color, vec4(SepiaMix), vec4(0.5));
vec4 Sepia = mix(Sepia1, Sepia2, SepiaMix);

gl_FragColor = mix(Color, Sepia, 1.0);
}
</cpp>

Shadersammlung

2008-11-07T23:19:17Z

Markus:

Die DGL Shadersammlung soll euch helfen Shader für OpenGL zu finden.

=Organisation=
==Aufbau==
Für den Anfang wird die Shadersammlung nicht gegliedert. Mit wachsender Anzahl der verlinkten Shader wird sich dies ändern.
==Vorlage==
Falls ihr einen Shader bereitstellen wollt sind drei Dinge nötig:
# Kopiert die nachfolgende Vorlage ans Ende der Shaderliste und tragt die passenden Daten ein.
# Erstellt einen neuen Shaderartikel den ihr in der eingefügten Zeile verlinkt. Benutzt dazu die [[Shaderartikelvorlage]]. Shaderartikel müssen mit '''shader_''' benannt sein. ''z.B. shader_Wasser2d'' für einen 2D Wassershader.
# Da Shader zu 90% optische Effekte bewirken, sollte (mindestens) ein aussagekräftiges Beispielbild im Shaderartikel hinterlegt werden. Das Bild muss dann auch hier in der Liste verlinkt werden.

Fügt folgenden Code ans Ende der Shaderliste an:
!<nowiki>[[shader_HierNameEintragen]]</nowiki>
!HierNameEintragen
!Autorname
!Was macht der Shader.<nowiki> </nowiki>
''What does the shader do.''*
!<nowiki>[[Bild:Beispielbild.jpg|150px|150px]]</nowiki>

''* Die englische Beschreibung ist freiwillig. Hilft aber bestimmt den Shader zu verbreiten. Die deutsche Beschreibung ist Pflicht.''

Für euren neuen Shaderartikel sollte diese [[Shaderartikelvorlage]] benutzt werden. (Vorlage aufrufen, bearbeiten klicken, Alles kopieren und in euren neuen Shaderartikel einfügen.)

=Shader=
== ARB-Shader ==
{|{{Prettytable_B1}} width=100%
!width=20%|Link
!width=20%|Shadername
!width=20%|Autor
!width=40%|Kurzbeschreibung
!width=150px|Bild
|-
![[shader_surface_scattering(ARB)|shader_surface_scattering]]
!surface scattering
!dj3hut1
!Bestimmt die Distanz, die Licht durch ein Material zurücklegt.
 
''Calculates the distance of light through a material.''
![[Bild:Scattering_s.jpg|144px|150px]]
|}
== GLSL-Shader ==
{|{{Prettytable_B1}} width=100%
!width=20%|Link
!width=20%|Shadername
!width=20%|Autor
!width=40%|Kurzbeschreibung
!width=150px|Bild
|-
![[shader_verysimple]]
!verysimple
(standard texture binding)
!damadmax
!Ein einfacher Shader, welcher eine Textur an Vertices bindet. Dieser Shader baut damit das standard Texturierungsverhalten der fixen Pipeline nach. 
''A very simple shader. It only binds a texture on some vertices, thus this shader simulates the standard behavior of a part of the fixed pipeline.''
![[Bild:shader_verysimple.jpg|150px|150px]]
|-
![[shader_sepia]]
!Sepia
!Markus
!Post-Processing-Shader, welcher einen Sepia-Farbfilter auf die Szene anwendet. 
''Post-Processing-Shader which applies a sepia color filter to the scene.''
![[Bild:shader_sepia_nachher.jpg|150px|150px]]

|}
== Cg-Shader ==
{|{{Prettytable_B1}} width=100%
!width=20%|Link
!width=20%|Shadername
!width=20%|Autor
!width=40%|Kurzbeschreibung
!width=150px|Bild
|-
![[shader_diffuse_bumpmapping(Cg)|diffuse_bumpmapping]]
!diffuse_bumpmapping
!igel457
!Wendet diffuses Bumpmapping auf eine beliebige Oberfläche an. 
''Applies diffuse bumpmapping to a surface.''
![[Bild:shader_diffuse_bumpmapping_cg.jpg|150px|150px]]
|}