DGL Wiki - Benutzerbeiträge [de]

DGL Treffen/2016/Organisation

2016-05-30T18:22:42Z

Lord horazont: /* Was gibts zu erleben? */ let’s open that can of worms

Für den August 2016 planen wir wieder ein DGL Treffen. Diesmal geht es für 2 Wochen an die Küste von Dänemark.

;Thema: "Nerds On Tour." ;-)

Weitere Infos und detaillierte Besprechungen finden in [https://delphigl.com/forum/viewtopic.php?f=4&p=100328#p100328 diesem Forenthread] statt.

==Wo?==
Wird noch im Thread diskutiert.

==Wann?==
*Anreise: Sa. 06.08.2016
*Abreise: Sa. 20.08.2016

==Was kostet das?==
Je besser die Auslastung des Hauses, desto besser. Die Preise werden im gewohnten Rahmen bleiben.
Verpflegung und Anreise sind da aber nicht mit dabei. Die Verpflegung erfolgt üblicherweise über eine Umlage und wir holen uns gemeinsam etwas. Sollte jemand aus Kostengründen nicht teilnehmen können, kann er sich per Mail an Phobeus wenden.

==Wer kommt mit?==
Hier eine vorläufige Teilnehmerliste. Es sind insgesamt 8 Betten im Haus.
{|{{Prettytable_B1}}
!Teilnehmer
!Tage
(14=max)
!Anreise
!Kommentar
|-
|Phobeus
|14
|PKW
|(1,5 Plätze im PKW frei ab Hamburg.)
|-
|i0n0s
|14
|PKW
|(1 Platz im PKW frei ab Gießen.)
|-
|Polarwolf
|14
|PKW
|(1 Platz im PKW frei ab Hamburg.)
|-
|Seraliel
|2.5
|PKW
|(1 Platz frei ab Hamburg. Am Fr.12.8)
|-
|Flash
|14
|PKW
|3 Plätze ab Chemnitz (via Leipzig, Hannover)
|-
|TAK2004
|14
|
|Braucht ein Platz ab Berlin.
|-
|Mr Frase
|14
|---
|---
|-
|Ms Frase
|14
|---
|---
|End
|14
|
|Braucht einen Platz ab Hannover.
|-
|}

==Wie kommt man hin?==
Die Anreise steht noch nicht fest. Treffpunkt wird vor Hamburg sein, dort besteht die Möglichkeit die PKWs stehen zu lassen und sich besser auf die Wagen zu verteilen. Eine Anreise zum Bahnhof HH lässt sich ebenfalls organisieren. Fahrgemeinschaften bitte so früh wie möglich bilden!

==Was muss man persönlich mitbringen?==
* ggf. Reisekasse für eigene Einkäufe (Dänemark hat keinen Euro!)
* Bettwäsche und Handtücher
* Wechsel-Kleidung
* Reisedokumente (Führerschein, Personalausweis, Versicherungs- und Geldkarten)
* Reiseapotheke
* Hygieneartikel
* Badesachen (inkl. Sonnencreme)
* Sonstiges (was zu lesen, Schreibzeug etc.)

==Was müssen wir gemeinsammitbringen?==
* Klopapier
* Netzwerkkabel
* Steckdosenleisten
* Küchenequipement (Gewürze, Dosenöffner/Korkenzieher/Flaschenöffner, Kaffeefilter, Geschirrtücher, Wischtücher, Küchenrolle, Spülmittel)
* Elektronik (1 Router, Laptop, Netzwerkkabel, Fotoapparat)

==Was gibts zu erleben?==
*DGLer in echt ;)
*Spiel und Spannung
*Eine große weiße Leinwand zum bewundern
*Ausgebildete Barkeeper
*Baden und Grillen
*Mini-LAN
*Virtuelle Realitäten
*Live Projektvorstellung
*DänInnen, vereinzelt SchwedInnen *hust* ;)

==Was gibts zu essen?==
Flow: Ich sollte fast alles zubereitet bekommen, was aus dem Wasser kommt. Der Kauf ist üblicherweise direkt vom Kutter, die aber unregelmäßig rein kommen. Ein entsprechendes Backup sollte existieren.

{|{{Prettytable_B1}}
!Koch
!Speise
!Benötigte Zutaten
|-
|Thomas
|Pitataschen
|Tomaten, Paprika, Mais, Schafskäsen, Gurken, Tunfisch, Hänchenbrust, Pitataschen, Salami, Schinken, Gouda, Pfanne+Herd/Ofen/Toaster
|}

Shadersammlung

2015-04-11T14:27:42Z

Lord horazont: /* Geometrie */

==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 <u>nachdem</u> 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}}
{{excIcon}} Excellenter Artikel
|-
| {{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:'''<br>
[[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:'''<br>
[[GL_ARB_draw_instanced]]<br>
[[GL_EXT_gpu_shader4]]<br>
[[GL_EXT_texture_buffer_object]]<br>
[[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:'''<br>
[[GL_ARB_geometry_shader4]]
|-
| {{TableHead}} | [[shader_normal_debug_330|Normal Debugging-Shader für OpenGL 3.30+ Core]] von [[Benutzer:Lord Horazont|Lord Horazont]] {{ShaderLevel|4}}
| {{Table150R2}} | [[Bild:normal_debug_shader_330.png|150px|150px]]
|-
| {{TableCell}} | Dieser Shader nutzt einen Geometry Shader aus OpenGL 3.30 um die Normalen eines Modells ohne viel Aufwand anzuzeigen. {{ShaderLink|shader_normal_debug_330}}
|-
| {{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:'''<br>
[[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:'''<br>
[[GL_EXT_geometry_shader4]]<br>
[[GL_NV_transform_feedback]]<br>
[[GL_EXT_gpu_shader4]]<br>
[[GL_EXT_texture_buffer_object]]<br>
[[GL_ARB_texture_float]]<br>
[[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:'''<br>
[[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:'''<br>
[[GL_EXT_gpu_shader4]]
|-
| {{TableHead}} | [[shader_Mandelbrot|Mandelbrotfraktal Shader]] von [[Benutzer:Komoluna|Komoluna]]
| {{Table150R2}} | [[Bild:Mandelbrotshader blackwhite.png|150px|150px]]
|-
| {{TableCell}} | Ein Shader zum generieren eines Mandelbrotfraktals. {{ShaderLink|shader_Mandelbrot}}
|-
|}

==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:<br><tt> |-</tt><br><tt> | <nowiki>{{TableHead}} | [[shader_Wasser2d|2D Wassershader]] von [[Benutzer:DeinName|DeinName]]</nowiki></tt><br><tt> | <nowiki>{{Table150R2}} | [[Bild:Wassershader2D.jpg|150px|150px]]</nowiki></tt><br><tt> |-</tt><br><tt> | <nowiki>{{TableCell}}</nowiki> | Einige Sätze zur Beschreibung des Shaders. <nowiki>{{ShaderLink|shader_Wasser2d}}</nowiki></tt><br><tt> </tt><br><tt><nowiki>'''Extensions:'''<br></nowiki></tt><br><tt>Liste von notwendigen Extensions.</tt><br><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.

Shadersammlung

2015-04-11T14:27:06Z

Lord horazont: /* Geometrie */

==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 <u>nachdem</u> 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}}
{{excIcon}} Excellenter Artikel
|-
| {{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:'''<br>
[[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:'''<br>
[[GL_ARB_draw_instanced]]<br>
[[GL_EXT_gpu_shader4]]<br>
[[GL_EXT_texture_buffer_object]]<br>
[[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:'''<br>
[[GL_ARB_geometry_shader4]]
|-
| {{TableHead}} | [[shader_normal_debug_330|Normal Debugging-Shader für OpenGL 3.30+ Core]] von [[Benutzer::Lord Horazont|Lord Horazont]] {{ShaderLevel|4}}
| {{Table150R2}} | [[Bild:normal_debug_shader_330.png|150px|150px]]
|-
| {{TableCell}} | Dieser Shader nutzt einen Geometry Shader aus OpenGL 3.30 um die Normalen eines Modells ohne viel Aufwand anzuzeigen. {{ShaderLink|shader_normal_debug_330}}
|-
| {{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:'''<br>
[[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:'''<br>
[[GL_EXT_geometry_shader4]]<br>
[[GL_NV_transform_feedback]]<br>
[[GL_EXT_gpu_shader4]]<br>
[[GL_EXT_texture_buffer_object]]<br>
[[GL_ARB_texture_float]]<br>
[[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:'''<br>
[[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:'''<br>
[[GL_EXT_gpu_shader4]]
|-
| {{TableHead}} | [[shader_Mandelbrot|Mandelbrotfraktal Shader]] von [[Benutzer:Komoluna|Komoluna]]
| {{Table150R2}} | [[Bild:Mandelbrotshader blackwhite.png|150px|150px]]
|-
| {{TableCell}} | Ein Shader zum generieren eines Mandelbrotfraktals. {{ShaderLink|shader_Mandelbrot}}
|-
|}

==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:<br><tt> |-</tt><br><tt> | <nowiki>{{TableHead}} | [[shader_Wasser2d|2D Wassershader]] von [[Benutzer:DeinName|DeinName]]</nowiki></tt><br><tt> | <nowiki>{{Table150R2}} | [[Bild:Wassershader2D.jpg|150px|150px]]</nowiki></tt><br><tt> |-</tt><br><tt> | <nowiki>{{TableCell}}</nowiki> | Einige Sätze zur Beschreibung des Shaders. <nowiki>{{ShaderLink|shader_Wasser2d}}</nowiki></tt><br><tt> </tt><br><tt><nowiki>'''Extensions:'''<br></nowiki></tt><br><tt>Liste von notwendigen Extensions.</tt><br><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.

shader normal debug 330

2015-04-11T14:25:12Z

Lord horazont:

=Normalen Debugging mit OpenGL 3.3 Core=
Zurück zur [[Shadersammlung]]
{|{{Prettytable_B1}} width=100%
!width=60%|Beschreibung
!width=20%|Autor
!width=20%|Version
|-
|Nützlicher Shader um die Normalen eines Modells anzuzeigen.
|Lord Horazont, auf Basis von [[shader normal debug]]
|1.0
|}

==Bilder==
{|
|[[Datei:normal_debug_shader_330.png|framed|Terrain mit angezeigten Normalen]]
|}

==Beschreibung==
Dieser Shader nutzt einen Geometry Shader (OpenGL 3.3 Core) um die Normalen eines Modells anzuzeigen. Dazu wird das Modell einmal normal gerendert und dann nochmal mit dem Geometrieshader und einem spezialisierten Fragmentshader.

==Besondere Vorraussetzungen==
OpenGL 3.30 Core

Die Länge der anzuzeigenden Normalen wird über die Uniform-Variable ''normal_length'' gesteuert.

==Code==
Vom Vertex Shader wird angenommen, dass er die Normale als ``out vec3 normal;`` übergibt.

Geometry Shader:
<source lang="glsl">#version 330 core

layout(triangles) in;
layout(line_strip, max_vertices=6) out;

// (projection * view * model) matrix
uniform mat4 proj_view_model;

// length of the normal (object space)
uniform float normal_length;

in vec3 normal;

out NDData {
vec3 normal;
} nd_out;

void main() {
for (int i = 0; i < 3; i++) {
gl_Position = gl_in[i].gl_Position;
nd_out.normal = normal;
EmitVertex();
gl_Position = gl_in[i].gl_Position +
proj_view_model * vec4(normal * normal_length, 0.f);
nd_out.normal = normal;
EmitVertex();
EndPrimitive();
}
}</source>

Fragment Shader:
<source lang="glsl">#version 330 core

in NDData {
vec3 normal;
} nd_in;

out vec4 color;

void main() {
color = vec4(normalize(nd_in.normal) * 0.5 + 0.5, 1);
}</source>

shader normal debug 330

2015-04-11T14:24:54Z

Lord horazont: Die Seite wurde neu angelegt: „=Normalen Debugging mit OpenGL 3.3 Core= Zurück zur Shadersammlung {|{{Prettytable_B1}} width=100% !width=60%|Beschreibung !width=20%|Autor !width=20%|Ver…“

=Normalen Debugging mit OpenGL 3.3 Core=
Zurück zur [[Shadersammlung]]
{|{{Prettytable_B1}} width=100%
!width=60%|Beschreibung
!width=20%|Autor
!width=20%|Version
|-
|Nützlicher Shader um die Normalen eines Modells anzuzeigen.
|Lord Horazont
|1.0
|}

==Bilder==
{|
|[[Datei:normal_debug_shader_330.png|framed|Terrain mit angezeigten Normalen]]
|}

==Beschreibung==
Dieser Shader nutzt einen Geometry Shader (OpenGL 3.3 Core) um die Normalen eines Modells anzuzeigen. Dazu wird das Modell einmal normal gerendert und dann nochmal mit dem Geometrieshader und einem spezialisierten Fragmentshader.

==Besondere Vorraussetzungen==
OpenGL 3.30 Core

Die Länge der anzuzeigenden Normalen wird über die Uniform-Variable ''normal_length'' gesteuert.

==Code==
Vom Vertex Shader wird angenommen, dass er die Normale als ``out vec3 normal;`` übergibt.

Geometry Shader:
<source lang="glsl">#version 330 core

layout(triangles) in;
layout(line_strip, max_vertices=6) out;

// (projection * view * model) matrix
uniform mat4 proj_view_model;

// length of the normal (object space)
uniform float normal_length;

in vec3 normal;

out NDData {
vec3 normal;
} nd_out;

void main() {
for (int i = 0; i < 3; i++) {
gl_Position = gl_in[i].gl_Position;
nd_out.normal = normal;
EmitVertex();
gl_Position = gl_in[i].gl_Position +
proj_view_model * vec4(normal * normal_length, 0.f);
nd_out.normal = normal;
EmitVertex();
EndPrimitive();
}
}</source>

Fragment Shader:
<source lang="glsl">#version 330 core

in NDData {
vec3 normal;
} nd_in;

out vec4 color;

void main() {
color = vec4(normalize(nd_in.normal) * 0.5 + 0.5, 1);
}</source>

Datei:normal debug shader 330.png

2015-04-11T14:20:38Z

Lord horazont: Screenshot vom Normal Debug Shader für OpenGL 3.30

Screenshot vom [[shader normal debug 330|Normal Debug Shader für OpenGL 3.30]]

Link

2015-03-29T10:19:11Z

Lord horazont: /* Texturen */ fixed dead link

Diese Linksammlung soll allgemeine Links zu unterschiedlichen Themen bieten, die mit der Multimediaentwicklung zu tun haben.
{{Hinweis|Vielleicht ist eine Zusammenführung mit [[Tool]] sinnvoll!}}
{{Hinweis|Vielleicht ist eine Aufteilung in Unterseiten sinnvoll (möglicherweise mit Kategorien)}}

= Entwicklung mit OpenGL =

== Hardwareinfos ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://openglcaps.delphigl.de/ glCapsViewer Datenbank]
|{{Englisch}}
|Die Datenbank enthält alle mit [http://www.delphigl.com/forum/viewtopic.php?f=13&t=10010 glCapsViewer] gesammelten Informationen, also insbesondere OpenGL-Version und -Extensions verschiedener Grafikkarten.
|-
|[http://web.archive.org/web/20090417044334/http://delphi3d.net/hardware/listreports.php OpenGL Hardware Registry - Hardwareübersicht]
|{{Englisch}}
|Eine Datenbank aller Grafikkarten die in der Harware Registry vorhanden sind. Die einzelnen Artikel enthalten Infos darüber, welche Extensions von der Grafikkarte unterstützt werden.
|-
|[http://web.archive.org/web/20090506094005/http://delphi3d.net/hardware/ OpenGL Hardware Registry - Extensionübersicht]
|{{Englisch}}
|Eine Datenbank aller Extensions die in der Harware Registry vorhanden sind. Die einzelnen Artikel enthalten Infos darüber, welche Grafikkarten die entsprechende Extension unterstützen.
|-
|}


== Tutorials ==

{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
||[[Tutorial|DGL Wiki - Tutorial]]
|{{Deutsch}}
|DelphiGL.com ist Betreiber dieses Wikis und stellt eine Vielzahl Tutorials mit Schwehrpunkt OpenGL zur Verfügung.
Neben Tutorials für Einsteiger und OpenGL Anfänger gibt es auch fortgeschrittene Themen wie Shader oder Partikelsysteme.Sprache der Wahl ist hier Delphi.
|-
|[http://www.joachimrohde.com/cms/xoops/modules/articles/index.php?cat_id=1 joachimrohde.com]
|{{Deutsch}}
|Auf dieser Seite findet ihr deutsche Übersetzungen der bekannten NeHe Tutorials. Sprache der Wahl ist hier C++.
|-
|[http://www.cg.tuwien.ac.at/studentwork/VRSem96/OpenGL/ Technische Universität Wien]
|{{Deutsch}}
|Diese Seite bietet einen allgemeinen Überblick über die primären Funktionen von OpenGL und richtet sich vor allem an Einsteiger.
|-
|[http://nehe.gamedev.net/ Nehe]
|{{Englisch}}
|Die berühmt berüchtigten NeHe Tutorials sind eine umfangreiche Sammlung an Tutorials zum Thema OpenGL. Von Anfängertutorials bis hin zu komplexen Effekten wird alles behandelt. Sprache der Wahl ist hier C++. (Eine Übersetzung der NeHe Tutorials findet ihr bei Joachim Rhode (siehe oben). )
|-
|[http://www.sulaco.co.za/tut.htm sulaco.co.za]
|{{Englisch}}
| OpenGL Beispiele in Delphi
|}

== OpenGL Funktionen ==

=== GL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GL|DGL Wiki - Kategorie GL]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten OpenGL Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL.tar.gz OpenGL.org - Original Spezifkationen]
|{{Englisch}}
|Die Originalspezifikationen der OpenGL 1.0 und OpenGL 1.1 Befehle. (Diese HTML-Dokumente sind nicht Copy&Paste freundlich, da sie vermutlich automatisch aus vorhandenen Dateien (Postscript) erzeugt wurden.)
|-
|[http://developer.3dlabs.com/documents/glmanpage_index.htm 3dLabs]
|{{Englisch}}
|Die Originalspezifikationen der OpenGL 1.0 und OpenGL 1.1 Befehle.
|-
|[http://web.archive.org/web/20040616082839/http://www.mevis.de/~uwe/opengl/opengl.html mevis.de]
|{{Englisch}}
|Sammlung von Englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|[http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/glfunc01_4f03.asp MSDN von Microsoft]
|{{Englisch}}
|OpenGL Dokumentation in der MSDN. Die Erklärung der MSDN sind meist keine reinen Kopien der Originalspezifikationen, sondern enthalten hin und wieder auch zusätzliche Informationen, oder formulieren Texte auf verständlichere Art und Weise.
|-
|}

=== GLU ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GLU|DGL Wiki - Kategorie GLU]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten GLU Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/glu/ OpenGL.org - Original Spezifkationen]
|{{Englisch}}
|Originalspezifikationen für die GLU Befehle. (Diese HTML-Dokumente sind nicht Copy&Paste freundlich, da sie vermutlich automatisch aus vorhandenen Dateien (Postscript) erzeugt wurden.)
|-
|[http://web.archive.org/web/20040616082839/http://www.mevis.de/~uwe/opengl/opengl.html mevis.de mevis.de]
|{{Englisch}}
|Sammlung von englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|[http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/glufnc01_0e43.asp MSDN von Microsoft]
|{{Englisch}}
|GLU Dokumentation in der MSDN. Die Erklärung der MSDN sind meist keine reinen Kopien der Originalspezifikationen, sondern enthalten hin und wieder auch zusätzliche Informationen, oder formulieren Texte auf verständlichere Art und Weise.
|-
|}

=== GLX ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GLX|DGL Wiki - Kategorie GLX]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten GLX Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/glx/ OpenGL.org - Original Spezifkationen]
|{{Englisch}}
|Orgninalspezifikationen der GLX Befehle bei OpenGL.org.
|-
|[http://web.archive.org/web/20040616082839/http://www.mevis.de/~uwe/opengl/opengl.html mevis.de mevis.de]
|{{Englisch}}
|Sammlung von Englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|}

=== WGL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:WGL|DGL Wiki - Kategorie WGL]]
|{{Deutsch}}
|Wiki-Kategorie die alle übersetzten WGL Befehle enthält.
|-
|[http://web.archive.org/web/20071218151417/http://developer.3dlabs.com/documents/wglmanpage_index.htm 3dLabs]
|{{Englisch}}
|Sammlung einiger WGL Befehlsspezifikationen.
|-
|}

=== GLUT ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://freeglut.sourceforge.net/docs/api.php The freeglut Projekt]
|{{Englisch}}
|Englischsprachige Dokumentation zum OpenGL Utility Toolkit kurz GLUT.
|-
|}

=== SDL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:SDL|DGL Wiki - Kategorie SDL]]
|{{Deutsch}}
|Übersicht aller auf die SDL bezogenen Artikel hier im Wiki. Darunter befinden sich eine Vielzahl von Übersetzungen der SDL Befehlspezifikationen. Diese können auch in der [[SDL-Funktionsübersicht]] gefunden werden.
|-
|[http://www.libsdl.org/cgi/docwiki.cgi/SDL_20API libsdl.org]
|{{Englisch}}
|Das Dokumentationswiki von libSDL.org enthält die komplette Dokumenation zur SDL in englischer Sprache.
|-
|-
|[http://www.freepascal-meets-sdl.net/ freepascal meets sdl]
|{{Englisch}}
| Eine Webseite die speziell Informationen über die Programmierung von SDL unter Freepascal zur Verfügung stellt.
|-
|}

== FAQs ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[FAQ| DGL Wiki - FAQ]]
|{{Deutsch}}
|Ein FAQ (Frequently Asked Questions = Häufig gestellte Fragen) zu DelphiGL.com und dem DGL Wiki.
|-
|[http://www.3dsource.de/faq/index.htm 3dsource.de]
|{{Deutsch}}
|Ein FAQ zu Fragen rund um OpenGL.
|-
|}

== Effekte und Techniken mit OpenGL ==

===Glow===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamasutra.com/view/feature/2107/realtime_glow.php Gamasutra]
|{{Englisch}}
|Beschreibt, wie man mit Hilfe von Shader(hier DirectX Shader) den Gloweffekt in Realtime umsetzt. Dabei wird erst die Technik dahinter erklärt, und dann wie man sie Schritt für Schritt umsetzt.
|-
|[http://web.archive.org/web/20071118043007/http://collective.valve-erc.com/index.php?go=tron1 valve-erc.com]
|{{Englisch}}
|Schritt für Schritt Anleitung, wie man mit Hilfe von Cg in OpenGL den Glow Effekt realisieren kann
|-
|}

===HDR===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://web.archive.org/web/20090601052809/http://www.gamedev.net/columns/hardcore/hdrrendering/ gamedev.net]
|{{Englisch}}
|Hier wird sehr kurz eingeleitet, was HDR Rendering überhaupt ist, dann wird der Aufbau des *.hdr Formats erläutert, und dann geht es schon von 0 auf 100 zum Programmieren. Erklärungen gibt es kaum, dafür werden fertige Shader(für DirectX) geboten.
|-
|[http://web.archive.org/web/20090601202039/http://www.gamedev.net/reference/articles/article2208.asp gamedev.net]
|{{Englisch}}
|Beschreibt auch nur etwas kurz das HDR Verfahren, jedoch mit mehr mathematischen Hintergrund in Sachen Tonemapping. Beispielcode für Tonemapping in C++ liegt bei.
|-
|}

===BSP Bäume===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://web.archive.org/web/20081201115631/http://www.3dtechdev.com/tutorials/leafbsp/3dbsptrees.html 3dtechdev.com]
|{{Englisch}}
|Das beste Dokument überhaupt, für allem die selber BSP Bäume compilieren möchte. Ist belegt mit sehr viel Grafik. Erst beginnt er das Prinzip allgemein zum umschreiben, dann wird alles genau erläutert, und mit verständlichen Pseudocode untermalt.
|-
|[http://web.archive.org/web/20081019041535/http://www.3dtechdev.com/tutorials/illegalgeometry/illegalgeometrytut.html 3dtechdev.com]
|{{Englisch}}
|Nicht ganz so gut geworden, wie sein erstes Tutorial, aber erklärt auch sehr gut, wie man illegale Geometrie aufspürt und beseitigt. Wieder mit Grafiken und Pseudocodes verständlich belegt. Hiermit kann man seinem Map-Compiler den letzten Schliff verleien.
|-
|[http://www.gamedev.net/reference/articles/article981.asp Gamedev]
|{{Englisch}}
|Von Michael Abrash, dürfte der ''Erfinder'' von Quake sein. Naja, meine Englischkenntnisse reichen hier nicht ganz aus, um den Text zu verstehen. Ist etwas umständlich geschrieben. Dafür mit Grafiken unterlegt.
|-
|[http://www.zfx-online.de/Tutorials.php?ID=11 Part 1 - Allgemein]
|{{Deutsch}}
|Einzigste deutsche Referenz zu BSP Bäumen, dafür Daumen hoch. Ist aber nicht das Wahre: schlechter C Code, und ich hatte auch nicht den Einduck, das er die Theorie zu diesem Thema bis in die Tiefe verstanden hat(oder er wollte es nicht zu akademisch Erklären oO). Aber ein guter Einstieg in dieses Thema.
|-
|[http://www.zfx-online.de/Tutorials.php?ID=13 Part 2 - Kollision und PVS]
|{{Deutsch}}
|-
|[http://web.archive.org/web/20060516103821/http://www.cs.uwec.edu/~stevende/cs455/programs/GameTutorials%20-%20Quake%203%20BSP%20Format.htm Quake3 *.bsp Format]
|{{Englisch}}
|Die beste Dokumentation für das BSP Format, die ich gefunden habe, besser als den Quake3 Sourcecode zu durchforsten. Leider etwas magere Eklährung zu wichtigen Themen wie Patches(Curved Surfaces). Ich pers. hatte jetzt 1 1/2 Wochen gebraucht, um das *.bsp Format vollständig zu verstehen. Ist aber anscheinend die beste Format Dokumentation im Netz.
|-
|[http://www.flipcode.com/articles/article_q2bsp.shtml Quake2 *.bsp Format]
|{{Englisch}}
|Kann auch nur soviel sagen, wie beim Link zuvor. Es fehlen hier auch zum Teil Informationen. Man muss halt viel ausprobieren, und sich den Quake 2 Source zu Herzen nehmen, damit man es versteht.
|-
|}

===Himmel & Wolken===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamedev.net/community/forums/topic.asp?topic_id=86024 Gamedev]
|{{Englisch}}
|Guter Thread mit vielen Anregungen und Links.
|-
|[http://www.gamedev.net/community/forums/topic.asp?topic_id=135654 Gamedev]
|{{Englisch}}
|Hier wird die Diskussion zum obigen Link weitergeführt.
|-
|[http://freespace.virgin.net/hugo.elias/models/m_clouds.htm Plasma]
|{{Englisch}}
|Eine nette Idee um Plasma in Echtzeit zu generieren, und zu verändern. Leider nichts zum Shading.
|-
|[http://nis-lab.is.s.u-tokyo.ac.jp/~nis/cdrom/sig00_cloud.pdf 3D Wolken]
|{{Englisch}}
|Paper über generieren und rendern von 3 dimensionalen Wolken inklusive Schatten und Lichtstrahlen. Ich hab nur den Lichtstahlen-Algorithmus ausprobiert. Saulangsam aber sehr einfach zu implementieren. Einen Blick ist es auf jeden Fall wert.
|-
|[http://web.archive.org/web/20031011052035/http://www.geocities.com/ngdash/whitepapers/skydomecolor.html Skydome]
|{{Englisch}}
|Wenn man mal schnell gute Farben für seinen Skydome braucht...
|}

===Terrain===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.flipcode.com/articles/article_geomipmaps.shtml FlipCode]
|{{Englisch}}
|Artikel zu Geomipmaping. Zummindest hab ich es hier zum ersten mal gesehen. Und es funzt ganz gut.
|-
|[http://www.vterrain.org Virtual Terrain Project]
|{{Englisch}}
|Eine Seite mit Links und Artikeln zu allem, was etwas mit Terrainrendering zu tun hat.
|-
|}

===Sonstiges===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[Materialsammlung]]
|{{Deutsch}}
|Sammlung von gängigen Parametern für [[glMaterial]] hier im Wiki.
|-
|[http://freespace.virgin.net/hugo.elias/radiosity/radiosity.htm Radiosity]
|{{Englisch}}
|Erklärt sehr schön die Funktionsweise von Radiosity, liefert Beispielcodes und ist recht gut illustriert.
|-
|[http://web.archive.org/web/20050825110920/http://legion.gibbering.net/projectx/paper/shadow%20mapping/ Shadowmapping]
|{{Englisch}}
|Beschreibt das Trapezoidal Shadow Mapping - Verfahren für gerichte Lichter.
|-
|[http://www.flipcode.com/articles/article_generatingnames.shtml Namensgenerator]
|{{Englisch}}
|Per Zufallsgenrator Namen erzeugen, und nie wieder kreativ werden müssen.
|-
|[http://www.paulsprojects.net/tutorials/simplebump/simplebump.html Bumpmapping]
|{{Englisch}}
|Bumpmapping auf Lowend-Grakas. Damals war Bumpmapping noch was ganz tolles...
|-
|[http://www.paulsprojects.net/opengl/dpreflect/dpreflect.html Dot Product Reflect]
|{{Englisch}}
|zwar nur ne Demo, aber wenn man schon immer mal mit EMBM das Wasser aus Morrowind nachproggen wollte...
|-
|}

== Beispiele/Demos mit Quelltext ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.delphigl.de DelphiGL.de]
|{{Deutsch}}
| Hier finden sich besonders eindrucksvolle Newton Physik Demos. Meißtens sogar mit Quelltext.
|-
|[http://www.shadow3d.de.vu/ Shadow 3D]
|{{Deutsch}}
| Hier finden sich zwei Demos wie man Quake 3 Modelle lädt und eine glSlang Demo
|-
|[[Shadersammlung]] im DGL Wiki
|{{Deutsch}}
| Hier findet man freie Shadersourcen.
|-
|[http://www.humus.name Humus]
|{{Englisch}}
| Diverse eindrucksvolle Demos zu verschiedenen Techniken, häufig mit Quelltext in C (teilweise OpenGL / DirectX)
|}

== weitere Links ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www-user.tu-chemnitz.de/~pester/Lehre/CompGeo.pdf CompGeo.pdf]
|{{Deutsch}}
| Script "Einführung in die Computergeometrie" von Dr. Pester (TU-Chemnitz). Ideales Nachschlagewerk für die Mathematik die einem bei der Grafikprogrammierung so begegnet.
|-
|[http://www.robsite.de/ robsite.de]
|{{Deutsch}}
| Auf dieser riesigen Seite finden sich auch viele weitere Links über verschiedene Themen der 3D Programmierung.
|-
|[http://www.3dlinks.com/links.cfm?categoryid=3&subcategoryid=21 3dlinks.com]
|{{Englisch}}
| Diese Seite hat es sich zur Hauptaufgabe gemacht Links auf Seiten mit dem Thema 3D zu sammeln.
|-
|[http://www.two-kings.de/links.html two-kings.de]
|{{Englisch}}
| Sammlung diverser interessanter Links, vorallem auf Themen im gamedev-Forum verweisend.
|-
|[http://www.delgine.com Delgine.com]
|{{Englisch}}
| Heimat des freien 3D Modellers "DeleD", welcher in Delphi programmiert ist. Ihr findet dort auch Modellpackete, Texturpackete, Plugins und Hilfe bei der Programmierung von Delphi und OpenGL.
|}

= Spieleentwicklung =

==Allgemein==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.spieleprogrammierung.net/ Spieleprogrammierung - OpenGL - GLSL - OpenAL - KI - Animation - Spielephysik]
|{{Deutsch}}
|Auf dieser Seite findet Ihr Artikel, Tutorials und Programmbeispiele rund um das Thema Spieleprogrammierung. Programmiersprache ist hier C/C++.
|-
|[http://graphics-and-physics-framework.spieleprogrammierung.net/ OpenGL Graphics And Physics Framework]
|{{Deutsch}}
|Auf dieser Seite findet Ihr ein frei verfügbares OpenGL basiertes Grafik und Physik Framework (LGPL-Lizenz) samt zugehöriger Probammbeispiele. Programmiersprache ist hier C/C++.
|-
|[http://audio-framework.spieleprogrammierung.net/ OpenAL Audio Framework]
|{{Deutsch}}
|Auf dieser Seite findet Ihr ein frei verfügbares OpenAL Audio Framework (LGPL-Lizenz) samt zugehöriger Probammbeispiele. Unterstützt werden 3D Sounds, EFX (EAX Alternative) Reverb Effekte sowie Audio Streaming (Music and Voices). Programmiersprache ist hier C/C++.
|-
|[http://spieleentwicklung-im-web.spieleprogrammierung.net/ Spieleentwicklung im Web]
|{{Deutsch}}
|Auf dieser Seite findet Ihr Links (E-Books, Präsentationen, wissenschaftliche Arbeiten und Tutorials) zu verschiedenen Themengebieten der Spieleentwicklung.
|-
|[http://harablog.wordpress.com/2011/08/26/fast-pathfinding-via-symmetry-breaking/ Fast pathfinding via symmetry breaking]
|{{Englisch}}
|Optimierungen für A* Pfadsuche durch Ausnutzung von Symmetrien.
|-
|}

==Kopierschutz==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://inner-smile.com/nocrack.phtml Inner-Smile.com]
|{{Englisch}}
| Seite mit Gedanken zum Thema "Wie schütze ich meine Programme vor Crackern". Falls die Seite nicht erreichbar ist hat Google noch ne [http://www.google.com/search?q=cache:hpqPT5G4WB0J:www.inner-smile.com/nocrack.phtml+http://inner-smile.com/nocrack.phtml&hl=de&gl=de&ct=clnk&cd=1 Version im Archiv].
|-
|}

== Künstliche Intelligenz ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://web.archive.org/web/20080319034335/http://www.kbs.uni-hannover.de/Lehre/KI2/Presentationen/presentation9798/esprit/spieltheorie/spieltheorie.html Uni-Hannover - Spieltheorie]
|{{Deutsch}}
|Artikel über die Grundlagen von KI in Spielen.
|-
|[http://web.archive.org/web/20080927010337/http://www.robsite.de/tutorials.php?tut=ki Robsite KI-Tutorials]
|{{Deutsch}}
| Sammlung von Texten zum Thema KI in Spielen. Beispiele sind meist in C++.
|-
|[http://ai-depot.com/ AI-Depot.com]
|{{Englisch}}
| Seite die sich ausschließlich mit KI in Spielen beschäftigt.
|-
|[http://www.ai-junkie.com/links.html AI-Junkie.com]
|{{Englisch}}
|Linkseite mit vielen KI relevanten Links. Die Seite AI-Junie selbst behandelt auch viele Themen rund um KI.
|-
|[http://www.aiwisdom.com/ AIWisdom.com]
|{{Englisch}}
|Seite die sich mit KIs in Spielen beschäftigt und sich zum Ziel gesetzt hat, alle Artikel zum Thema zu finden und zu Katalogisieren. Es gibt hier auch Artikel über die KIs bestehender Spiele.
|-
|[http://www.aiguru.com/ AIGuru.com]
|{{Englisch}}
|Newsseite zum Thema KI, Künstliches Leben, Hiernforschung, Robotik, Nanotechnologie - Halt alles was Spaß macht.
|-
|[http://www.generation5.org/ Generation5.org]
|{{Englisch}}
|Seite über KI, Robotik, etc. . Leider scheint die Seite Probleme zu haben regelmäßig aktualisiert zu werden. Aber zumindest sollte man einige Artikel finden. Die werden ja nicht schlecht.
|-
|[http://web.archive.org/web/20080702005527/http://www.gameai.com/ www.gameai.com]
|{{Englisch}}
|''Wurde Januar 2010 als down gemeldet. Weiss irgendwer etwas genaueres?'' Seite zum Thema KI in Spielen. Soll wohl einen gewissen Stellenwert in der AI-Szene haben.
|-
|[http://www-i1.informatik.rwth-aachen.de/~algorithmus/algo19.php Algorithmus der Woche - Informatikjahr 2006]
|{{Deutsch}}
|Vielleicht schon etwas älter aber doch eine gute Anleitung um eine einfache Schach-KI zu erstellen.
|}

= Ressourcen =
In dieser Gruppe finden sich Links um die Ressourcen für Eure Projekte zu erstellen.

{| width = "100%" {{Prettytable_B1}}
!width="20%"|Link
!width="80%"|Beschreibung
|-
|[http://opengameart.org/ opengameart.org]
|Eine Seite die es jedem anbietet Spielressourcen wie Musik, Texturen, 3D-Modelle und anderes hochzuladen und diese unter einer beliebigen Lizenz zu veröffentlichen.
|}

== Texturen / 2D-Grafiken ==

'''Legende:'''
:'''Kostenpflichtige Seiten''' sind mit einem * zu '''kennzeichnen'''
:GPL: Kompatibel mit der GPL
:MPL: Kompatibel mit der MPL
:OSS: Verwendung in OpenSource Software nicht verboten
:CSS: Verwendung in ClosedSource Software nicht verboten
:Komm: Verwendung in kommerzieller Software nicht verboten

=== Texturen ===
{| width = "100%" {{Prettytable_B1}}
!width="20%"|Link
!width="10%"|Genre
!width="10%"|Lizenz
!width="5%"|GPL
!width="5%"|MPL
!width="5%"|OSS
!width="5%"|CSS
!width="5%"|Komm.
!width="35%"|Bemerkungen
|-
|[http://www.davegh.com/ davegh.com]
|Fantasy
|[http://www.davegh.com/legal.php Eigene]
|?
|?
|✔
|✔
|✘
|Die Lizenz vererbt sich in die Projekte hinein.
|-
|[http://www.cgtextures.com/ cgtextures.com]
|Allgemein
|[http://www.cgtextures.com/content.php?action=license Eigene]
|✘
|✘
|✘
|?
|?
|Die Lizenz will im wesentlichen verhindern das Texturen in anderen Textursammlungen auftauchen. So wie ich das verstehe ist es kein Problem die Texturen unter einer anderen Lizenz zu veröffentlichen als die eigentliche Software. Die Software kann also sehr wohl OpenSource sein. Im Zweifelsfalls einfach den Support anschreiben, der ist sehr nett.
|-
|[https://wiki.openstreetmap.org/wiki/Texture_Library OpenStreetMap Texture Library]
|Allgemein
|Public Domain
|✘
|✘
|✘
|✘
|✘
|Die Texturen dienen der Visualisierung der 3D-Gebäude im OpenStreetMap Projekt
|-
|url
|Futuristisch, Mittelalter, etc.
|CC-BY-SA, etc., gerne auch mit Direktlink auf die Lizenzseite, so vorhanden.
|✔/✘/?
|✔/✘/?
|✔/✘/?
|✔/✘/?
|✔/✘/?
|Alle Bilder sind von Käse
|}

=== Sonstige 2D-Grafiken ===

{| width = "100%" {{Prettytable_B1}}
!width="20%"|Link
!width="45%"|Beschreibung
!width="10%"|Lizenz
!width="5%"|GPL
!width="5%"|MPL
!width="5%"|OSS
!width="5%"|CSS
!width="5%"|Komm.
|-
|[http://www.famfamfam.com/lab/icons/silk/ famfamfam silk]
|Iconset, welches inzwischen relativ weit verbreitet ist. 700 sauber gezeichnete, erkennbare PNG-Icons in TrueColor. Man kann praktisch jede (Arbeits-)Anwendung mit diesem Set vollständig mit Icons versorgen.
|[http://creativecommons.org/licenses/by/2.5/ CC-BY 2.5], [http://creativecommons.org/licenses/by/3.0/ CC-BY 3.0]
|✔
|✔
|✔
|✔
|✔
|}

=== Texturerstellung ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://3d.diehlsworld.de/textures/index.htm 3d.diehlsworld.de]
|{{Deutsch}}
|Auf dieser Seite findet ihr kurze aber inhaltlich reiche Tutorials zu der Frage "Wie erstelle ich XXXXX-Texturen". Dabei reicht die Palette von Untergrundtexturen wie Gras, Sand , Fels und Wasser (und Kombinationen dieser) bis hin zu Blitzen und Partikeln. Als Programm wird hier Photoshop verwendet.
|-
|[http://www.gimps.de/gimp/textur-muster/ gimps.de]
|{{Deutsch}}
|Schritt für Schritt Anleitungen wie man mit Gimp verschiedene Texturen erstellt.
|-
|[http://cbt.k090999.de/gimp.php#texturen k090999.de]
|{{Deutsch}}
|Gimptutorials zum Erstellen verschiedene Texturen.
|}

== Modelle / 3D-Grafiken ==

=== Blender ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://blendpolis.de/f/viewtopic.php?t=5786 Blendpolis]
|{{Deutsch}}
| Ein Thread im Forum von [http://blendpolis.de Blendpolis] in dem '''sehr''' viele Tutorials aufgelistet sind
|-
|[http://blendpolis.de/f/article_cat.php?fldAuto=7 Blendpolis]
|{{Deutsch}}
| Eigentliche Tutorial Seite von [http://blendpolis.de Blendpolis] die Auswahl ist hier aber nicht so groß
|-
|[http://wikivid.com/index.php/Blender Blender at wikivid.com]
|{{Englisch}}
| Linksammlung von Blender Video Tutorials
|-
|[http://www.blender.org/education-help/tutorials/getting-started/ blender3d.org]
|{{Englisch}}
| Auch die Heimatseite von Blender bietet viele Tutorials unter anderm auch Video Tuorials
|-
|[http://www.Blenderunderground.com Blenderunderground]
|{{Englisch}}
| '''sehr gute''' Video-Tutorials
|}

== Sounds ==

===Musik===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.jamendo.com/ Jamendo.com]
|{{Englisch}}
|Viele Künstler stellen hier ihre Alben unter einer Creative Commons Lizenz online. Man kann dort die Künstler auch kontaktieren und fragen ob man ihre Musik nutzen kann. Taugt außerdem als Radio! ;)
|-
|[http://incompetech.com/m/c/royalty-free/ Incompetech.com]
|{{Englisch}}
|Viele sehr schön gemacht instrumentale Musik aus allen möglichen Genres. Sie ist frei verwenderbar, wenn man den Macher der Musik (Kevin MacLeod) in seinem Programm erwähnt. Aber das hat er auch verdient. Folgende Programme nutzen beispielsweise (auch) Musik von incompetech.com:
* OpenParty
|-
|}

===Soundeffekte===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.freesound.org/ freesound.org]
|{{Englisch}}
|Diverse Sounds unter [http://www.creativecommons.org/ CreativeCommons] Lizenzen.
|}

===Soundprogramme===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://audacity.sourceforge.net/?lang=de Sourceforgeseite von Audacity]
|{{Deutsch}}
|Ein einfaches, freies Programm um Sounddateien zu bearbeiten. Man kann es auch nutzen um Soundeffekte neu zu erstellen, indem man z.B. ein Geräusch mit dem Mikrofon aufnimmt und einige Effekt anwendet, um es passender und nicht mehr aufgenommen klingen zu lassen.
|-
|[http://lmms.sourceforge.net/ LMMS]
|{{Englisch}}
|LMMS (Linux MultiMedia Studio) ist ein OpenSource+Freeware Composer-Programm ähnlich zum bekannteren aber auch teuren CuBase(r). Trotz des Namens auch für Windows erhältlich.
|}

GL ARB imaging

2014-07-03T14:09:07Z

Lord horazont: /* Ressourcen */ delphi3d.net hardwaredatenbank -> glCapsViewer datenbank

{{Unvollständig}}
= GL_ARB_imaging =

== Abfragestring ==
GL_ARB_imaging

== Beschreibung ==
Diese Extension wurde mit OpenGL 1.2 eingeführt und vereint die folgenden Extensions zu OpenGL 1.1 im sogenannten Imaging Subset.
:Farbtabellen [[GL_SGI_texture_color_table]]
:Faltung (Convolution) [[GL_EXT_convolution]]
:Die Color Matrix [[GL_SGI_color_matrix]]
:Histogramm und Minimum, Maximum Funktionen [[GL_EXT_histogram]]
:Zusätzliche Blending Equations und Blending Funktionen [[GL_EXT_blend_subtract]],[[GL_EXT_blend_minmax]].

Die Operationen werden ausschliesslich beim PixelTransfer [[glDrawPixels]], [[glCopyPixels]] angewandt.

=== '''Verwendung''' ===

=== '''Operanden''' ===

== Ressourcen ==
[http://delphigl.de/glcapsviewer/listreports.php?listreportsbyextension=GL_ARB_imaging Hardware Unterstützung]

Texelgenaue Texturkoordinate

2014-05-27T18:17:41Z

Lord horazont: Zusammenfassungstext + korrigierte Aussage bei Mipmap für GL_NEARESt

[[Texelgenaue Texturkoordinate|Texelgenaue Texturkoordinaten]] werden immer dann gebraucht, wenn man mehrere Bilder in einer Textur hat, z.B. bei einer [[Tilemap]] oder wenn man zur Laufzeit einen dynamischen [[Texturatlas]] erzeugt.

= Anwendungsgebiet =

[[Datei:Beispiel_Texturatlas.png|thumb|256px|Beispiel eines Texturatlas. Unterschiedliche Texturen sind in einem Bild untergebracht.]]

Ein häufiges Anwendungsgebiet ist wie schon erwähnt das Addressieren von Texturen in einem Texturatlas. Dazu muss man Pixelgenau die einzelnen Teilbilder herausschneiden, um sie auf Objekten anzubringen.

Wenn der Ausschnitt die Pixel im Rechteck ''x0..x1'', ''y0..y1'' abdeckt, dann ist die intuitive Methode um die Texturkoordinaten ''u0,u1,v0,v1'' für eine Textur der Breite ''w'' und Höhe ''h'' zu erhalten:

<code>
u0 = x0 / w
u1 = x1 / w
v0 = y0 / h
v1 = y1 / h
</code>

== Beispiel ==

Um das zweite Tile von links in der untersten Zeile auszuwählen, müssen wir das Rechteck mit ''x0=64'', ''x1=128'', ''y0=192'', ''y1=256'' aus der Textur mit ''w=256'', ''h=256'' rausschneiden. Damit erhalten wir:

<code>
u0 = x0 / w = 0.2500
u1 = x1 / w = 0.5000
v0 = y0 / h = 0.7500
v1 = y1 / h = 1.0000
</code>

= Problematik =

{{Hinweis|Die Problematik tritt nicht auf, wenn man '''GL_NEAREST''' verwendet. In dem Fall reicht es, die obige Methode zur Berechnung der Texturkoordinaten zu verwenden.}}

Diese Koordinaten bergen allerdings Probleme in sich, sobald man einen anderen Texturfilter als [[glTexParameter#Vergleich_zwischen_verschiedenen_Texturfilter|GL_NEAREST]] verwendet und die Texel nicht 1:1 auf Pixel übertragen werden (also irgendeine Form der Skalierung der Textur statt findet).

[[Datei:Texturatlas_bleeding.png|frame|center|Ein Tile mit den obigen Texturkoordinaten auf ein 4×4 größeres Quad gezeichnet]] Dann kommt es zu ''bleeding''-Effekten, bei denen die nebenanliegenden Texturen in das gewollte Bild reinblenden. In dem Beispiel oben wurde das zweite Tile von links ganz unten (64 px×64 px) auf ein Quad welches mit 256 px×256 px gerendert wurde mit GL_LINEAR aufgebracht. Man kann deutlich erkennen wie die nebenanliegenden Tiles in das Tile hineinbleeden.

== Lösung 1: Texturaddressierung verändern ==

[[Datei:Texturatlas_offsetcoords.png|frame|Tile welches mit den links stehenden Koordinaten auf ein gleich großes Quad gezeichnet wurde (Screenshot um Faktor 2×2 interpolationsfrei hochskaliert)]]Eine Lösung für dies, die oft genannt wird, ist, den Rahmen der Texturaddressierung in die mitte der Texel zu legen. Dazu addiert bzw. subtrahiert man von den Texturkoordinaten einen halben Texel:

<code>
u0 = (x0 + 0.5) / w
u1 = (x1 - 0.5) / w
v0 = (y0 + 0.5) / h
v1 = (y1 - 0.5) / h
</code>

Dann liegen die Ränder des angezeigten Quads genau auf der Texelmitte, es findet also keine Überblendung mit nebenanliegenden Tiles statt. Dieser Ansatz hat allerdings ein anderes Problem: Die Texturen verschwimmen schon bei einer 1:1 Abbildung, wie im Screenshot rechts zu sehen.

== Lösung 2: Rahmen hinzufügen ==

[[Datei:Texturatlas_bordered.png|frame|center|Tile mit Rahmen, welches mit den originalen Texturkoordinaten auf ein 4×4 größeres Quad gezeichnet wurde]]Man kann den ''bleeding''-Effekt auch beheben, indem man einen 1 px Rahmen um die Texturen im Atlas hinzufügt, welcher die Farbe des anliegenden Texturpixels hat (und in den Ecken eventuell eine lineare Überblendung). Obiges Bild demonstriert, dass dies das Problem löst.

Allerdings hilft diese Lösung nicht, wenn man (automatisch generierte) Mipmaps verwendet. Dafür muss man den Rahmen für jedes Mipmap-Level verdoppeln, was ab einem gewissen Mipmap-Level zu viel Platz benötigt. Oft ist es allerdings so, dass man, wenn man Mipmaps braucht (also unterschiedliche Skalierungen einer Textur anzeigen will) sowieso keine pixelgenaue Darstellung benötigt.

Ein weiterer Nachteil ist, dass man N×M+4 Pixel verschwendet, von denen nur die Hälfte verwendet werden.

== Zusammenfassung ==

Wir stellen fest, dass alle Methoden ihre Vor- und Nachteile haben. Es gibt keine Pauschallösung für das Problem, wenn man nicht alle Bilder in separate Texturen packen will. Man muss sich also klar werden, welche Kriterien wichtig sind und dann die Methodik danach auswählen. Dazu sollte folgende Tabelle hilfreich sein:

{|{{Prettytable_B1}} width="100%"
!Technik / Kriterium
!Kein ''bleeding''
!Pixelgenaue Darstellung bei 1:1 Rendering
!Mipmap-Kompatibilität
!Lineares Filtering bei Zoom
|-
! style="text-align:left" |Normal mit GL_NEAREST
|✔
|✔
|✘
|✘
|-
! style="text-align:left" |Normal mit GL_LINEAR (ggfs. + Mipmap)
|✘
|✔
|✔
|✔
|-
! style="text-align:left" |Lösung 1: Ausschnitt verkleinern
|✔
|✘
|✔
|✔
|-
! style="text-align:left" | Lösung 2: Rahmen hinzufügen
|✔
|✔
|✘
|✔
|-
|}

Texelgenaue Texturkoordinate

2014-05-27T13:15:24Z

Lord horazont: GL_NEAREST als Option in der Zusammenfassung hinzugefügt

[[Texelgenaue Texturkoordinate|Texelgenaue Texturkoordinaten]] werden immer dann gebraucht, wenn man mehrere Bilder in einer Textur hat, z.B. bei einer Tilemap oder wenn man zur Laufzeit einen dynamischen Texturatlas erzeugt.

= Anwendungsgebiet =

[[Datei:Beispiel_Texturatlas.png|thumb|256px|Beispiel eines Texturatlas. Unterschiedliche Texturen sind in einem Bild untergebracht.]]

Ein häufiges Anwendungsgebiet ist wie schon erwähnt das Addressieren von Texturen in einem Texturatlas. Dazu muss man Pixelgenau die einzelnen Teilbilder herausschneiden, um sie auf Objekten anzubringen.

Wenn der Ausschnitt die Pixel im Rechteck ''x0..x1'', ''y0..y1'' abdeckt, dann ist die intuitive Methode um die Texturkoordinaten ''u0,u1,v0,v1'' für eine Textur der Breite ''w'' und Höhe ''h'' zu erhalten:

<code>
u0 = x0 / w
u1 = x1 / w
v0 = y0 / h
v1 = y1 / h
</code>

== Beispiel ==

Um das zweite Tile von links in der untersten Zeile auszuwählen, müssen wir das Rechteck mit ''x0=64'', ''x1=128'', ''y0=192'', ''y1=256'' aus der Textur mit ''w=256'', ''h=256'' rausschneiden. Damit erhalten wir:

<code>
u0 = x0 / w = 0.2500
u1 = x1 / w = 0.5000
v0 = y0 / h = 0.7500
v1 = y1 / h = 1.0000
</code>

= Problematik =

{{Hinweis|Die Problematik tritt nicht auf, wenn man '''GL_NEAREST''' verwendet. In dem Fall reicht es, die obige Methode zur Berechnung der Texturkoordinaten zu verwenden.}}

Diese Koordinaten bergen allerdings Probleme in sich, sobald man einen anderen Texturfilter als [[glTexParameter#Vergleich_zwischen_verschiedenen_Texturfilter|GL_NEAREST]] verwendet und die Texel nicht 1:1 auf Pixel übertragen werden (also irgendeine Form der Skalierung der Textur statt findet).

[[Datei:Texturatlas_bleeding.png|frame|center|Ein Tile mit den obigen Texturkoordinaten auf ein 4×4 größeres Quad gezeichnet]] Dann kommt es zu ''bleeding''-Effekten, bei denen die nebenanliegenden Texturen in das gewollte Bild reinblenden. In dem Beispiel oben wurde das zweite Tile von links ganz unten (64 px×64 px) auf ein Quad welches mit 256 px×256 px gerendert wurde mit GL_LINEAR aufgebracht. Man kann deutlich erkennen wie die nebenanliegenden Tiles in das Tile hineinbleeden.

== Lösung 1: Texturaddressierung verändern ==

[[Datei:Texturatlas_offsetcoords.png|frame|Tile welches mit den links stehenden Koordinaten auf ein gleich großes Quad gezeichnet wurde (Screenshot um Faktor 2×2 interpolationsfrei hochskaliert)]]Eine Lösung für dies, die oft genannt wird, ist, den Rahmen der Texturaddressierung in die mitte der Texel zu legen. Dazu addiert bzw. subtrahiert man von den Texturkoordinaten einen halben Texel:

<code>
u0 = (x0 + 0.5) / w
u1 = (x1 - 0.5) / w
v0 = (y0 + 0.5) / h
v1 = (y1 - 0.5) / h
</code>

Dann liegen die Ränder des angezeigten Quads genau auf der Texelmitte, es findet also keine Überblendung mit nebenanliegenden Tiles statt. Dieser Ansatz hat allerdings ein anderes Problem: Die Texturen verschwimmen schon bei einer 1:1 Abbildung, wie im Screenshot rechts zu sehen.

== Lösung 2: Rahmen hinzufügen ==

[[Datei:Texturatlas_bordered.png|frame|center|Tile mit Rahmen, welches mit den originalen Texturkoordinaten auf ein 4×4 größeres Quad gezeichnet wurde]]Man kann den ''bleeding''-Effekt auch beheben, indem man einen 1 px Rahmen um die Texturen im Atlas hinzufügt, welcher die Farbe des anliegenden Texturpixels hat (und in den Ecken eventuell eine lineare Überblendung). Obiges Bild demonstriert, dass dies das Problem löst.

Allerdings hilft diese Lösung nicht, wenn man (automatisch generierte) Mipmaps verwendet. Dafür muss man den Rahmen für jedes Mipmap-Level verdoppeln, was ab einem gewissen Mipmap-Level zu viel Platz benötigt. Oft ist es allerdings so, dass man, wenn man Mipmaps braucht (also unterschiedliche Skalierungen einer Textur anzeigen will) sowieso keine pixelgenaue Darstellung benötigt.

Ein weiterer Nachteil ist, dass man N×M+4 Pixel verschwendet, von denen nur die Hälfte verwendet werden.

== Zusammenfassung ==

{|{{Prettytable_B1}} width="100%"
!Technik / Kriterium
!Kein ''bleeding''
!Pixelgenaue Darstellung bei 1:1 Rendering
!Mipmap-Kompatibilität
!Lineares Filtering bei Zoom
|-
! style="text-align:left" |Normal mit GL_NEAREST
|✔
|✔
|—
|✘
|-
! style="text-align:left" |Normal mit GL_LINEAR (ggfs. + Mipmap)
|✘
|✔
|✔
|✔
|-
! style="text-align:left" |Lösung 1: Ausschnitt verkleinern
|✔
|✘
|✔
|✔
|-
! style="text-align:left" | Lösung 2: Rahmen hinzufügen
|✔
|✔
|✘
|✔
|-
|}

Texelgenaue Texturkoordinate

2014-05-27T13:12:27Z

Lord horazont: /* Lösung 2: Rahmen hinzufügen */ Overhead des Rahmens beschreiben

[[Texelgenaue Texturkoordinate|Texelgenaue Texturkoordinaten]] werden immer dann gebraucht, wenn man mehrere Bilder in einer Textur hat, z.B. bei einer Tilemap oder wenn man zur Laufzeit einen dynamischen Texturatlas erzeugt.

= Anwendungsgebiet =

[[Datei:Beispiel_Texturatlas.png|thumb|256px|Beispiel eines Texturatlas. Unterschiedliche Texturen sind in einem Bild untergebracht.]]

Ein häufiges Anwendungsgebiet ist wie schon erwähnt das Addressieren von Texturen in einem Texturatlas. Dazu muss man Pixelgenau die einzelnen Teilbilder herausschneiden, um sie auf Objekten anzubringen.

Wenn der Ausschnitt die Pixel im Rechteck ''x0..x1'', ''y0..y1'' abdeckt, dann ist die intuitive Methode um die Texturkoordinaten ''u0,u1,v0,v1'' für eine Textur der Breite ''w'' und Höhe ''h'' zu erhalten:

<code>
u0 = x0 / w
u1 = x1 / w
v0 = y0 / h
v1 = y1 / h
</code>

== Beispiel ==

Um das zweite Tile von links in der untersten Zeile auszuwählen, müssen wir das Rechteck mit ''x0=64'', ''x1=128'', ''y0=192'', ''y1=256'' aus der Textur mit ''w=256'', ''h=256'' rausschneiden. Damit erhalten wir:

<code>
u0 = x0 / w = 0.2500
u1 = x1 / w = 0.5000
v0 = y0 / h = 0.7500
v1 = y1 / h = 1.0000
</code>

= Problematik =

Diese Koordinaten bergen allerdings Probleme in sich, sobald man einen anderen Texturfilter als [[glTexParameter#Vergleich_zwischen_verschiedenen_Texturfilter|GL_NEAREST]] verwendet und die Texel nicht 1:1 auf Pixel übertragen werden (also irgendeine Form der Skalierung der Textur statt findet).

[[Datei:Texturatlas_bleeding.png|frame|center|Ein Tile mit den obigen Texturkoordinaten auf ein 4×4 größeres Quad gezeichnet]] Dann kommt es zu ''bleeding''-Effekten, bei denen die nebenanliegenden Texturen in das gewollte Bild reinblenden. In dem Beispiel oben wurde das zweite Tile von links ganz unten (64 px×64 px) auf ein Quad welches mit 256 px×256 px gerendert wurde mit GL_LINEAR aufgebracht. Man kann deutlich erkennen wie die nebenanliegenden Tiles in das Tile hineinbleeden.

== Lösung 1: Texturaddressierung verändern ==

[[Datei:Texturatlas_offsetcoords.png|frame|Tile welches mit den links stehenden Koordinaten auf ein gleich großes Quad gezeichnet wurde (Screenshot um Faktor 2×2 interpolationsfrei hochskaliert)]]Eine Lösung für dies, die oft genannt wird, ist, den Rahmen der Texturaddressierung in die mitte der Texel zu legen. Dazu addiert bzw. subtrahiert man von den Texturkoordinaten einen halben Texel:

<code>
u0 = (x0 + 0.5) / w
u1 = (x1 - 0.5) / w
v0 = (y0 + 0.5) / h
v1 = (y1 - 0.5) / h
</code>

Dann liegen die Ränder des angezeigten Quads genau auf der Texelmitte, es findet also keine Überblendung mit nebenanliegenden Tiles statt. Dieser Ansatz hat allerdings ein anderes Problem: Die Texturen verschwimmen schon bei einer 1:1 Abbildung, wie im Screenshot rechts zu sehen.

== Lösung 2: Rahmen hinzufügen ==

[[Datei:Texturatlas_bordered.png|frame|center|Tile mit Rahmen, welches mit den originalen Texturkoordinaten auf ein 4×4 größeres Quad gezeichnet wurde]]Man kann den ''bleeding''-Effekt auch beheben, indem man einen 1 px Rahmen um die Texturen im Atlas hinzufügt, welcher die Farbe des anliegenden Texturpixels hat (und in den Ecken eventuell eine lineare Überblendung). Obiges Bild demonstriert, dass dies das Problem löst.

Allerdings hilft diese Lösung nicht, wenn man (automatisch generierte) Mipmaps verwendet. Dafür muss man den Rahmen für jedes Mipmap-Level verdoppeln, was ab einem gewissen Mipmap-Level zu viel Platz benötigt. Oft ist es allerdings so, dass man, wenn man Mipmaps braucht (also unterschiedliche Skalierungen einer Textur anzeigen will) sowieso keine pixelgenaue Darstellung benötigt.

Ein weiterer Nachteil ist, dass man N×M+4 Pixel verschwendet, von denen nur die Hälfte verwendet werden.

== Zusammenfassung ==

{|{{Prettytable_B1}} width="100%"
!Technik / Kriterium
!Kein ''bleeding''
!Pixelgenaue Darstellung bei 1:1 Rendering
!Mipmap-Kompatibilität
|-
! style="text-align:left" |Normal
|✘
|✔
|✔
|-
! style="text-align:left" |Lösung 1: Ausschnitt verkleinern
|✔
|✘
|✔
|-
! style="text-align:left" | Lösung 2: Rahmen hinzufügen
|✔
|✔
|✘
|-
|}

Texelgenaue Texturkoordinate

2014-05-27T13:09:14Z

Lord horazont: Beispiel für Texturkoordinaten hinzugefügt

[[Texelgenaue Texturkoordinate|Texelgenaue Texturkoordinaten]] werden immer dann gebraucht, wenn man mehrere Bilder in einer Textur hat, z.B. bei einer Tilemap oder wenn man zur Laufzeit einen dynamischen Texturatlas erzeugt.

= Anwendungsgebiet =

[[Datei:Beispiel_Texturatlas.png|thumb|256px|Beispiel eines Texturatlas. Unterschiedliche Texturen sind in einem Bild untergebracht.]]

Ein häufiges Anwendungsgebiet ist wie schon erwähnt das Addressieren von Texturen in einem Texturatlas. Dazu muss man Pixelgenau die einzelnen Teilbilder herausschneiden, um sie auf Objekten anzubringen.

Wenn der Ausschnitt die Pixel im Rechteck ''x0..x1'', ''y0..y1'' abdeckt, dann ist die intuitive Methode um die Texturkoordinaten ''u0,u1,v0,v1'' für eine Textur der Breite ''w'' und Höhe ''h'' zu erhalten:

<code>
u0 = x0 / w
u1 = x1 / w
v0 = y0 / h
v1 = y1 / h
</code>

== Beispiel ==

Um das zweite Tile von links in der untersten Zeile auszuwählen, müssen wir das Rechteck mit ''x0=64'', ''x1=128'', ''y0=192'', ''y1=256'' aus der Textur mit ''w=256'', ''h=256'' rausschneiden. Damit erhalten wir:

<code>
u0 = x0 / w = 0.2500
u1 = x1 / w = 0.5000
v0 = y0 / h = 0.7500
v1 = y1 / h = 1.0000
</code>

= Problematik =

Diese Koordinaten bergen allerdings Probleme in sich, sobald man einen anderen Texturfilter als [[glTexParameter#Vergleich_zwischen_verschiedenen_Texturfilter|GL_NEAREST]] verwendet und die Texel nicht 1:1 auf Pixel übertragen werden (also irgendeine Form der Skalierung der Textur statt findet).

[[Datei:Texturatlas_bleeding.png|frame|center|Ein Tile mit den obigen Texturkoordinaten auf ein 4×4 größeres Quad gezeichnet]] Dann kommt es zu ''bleeding''-Effekten, bei denen die nebenanliegenden Texturen in das gewollte Bild reinblenden. In dem Beispiel oben wurde das zweite Tile von links ganz unten (64 px×64 px) auf ein Quad welches mit 256 px×256 px gerendert wurde mit GL_LINEAR aufgebracht. Man kann deutlich erkennen wie die nebenanliegenden Tiles in das Tile hineinbleeden.

== Lösung 1: Texturaddressierung verändern ==

[[Datei:Texturatlas_offsetcoords.png|frame|Tile welches mit den links stehenden Koordinaten auf ein gleich großes Quad gezeichnet wurde (Screenshot um Faktor 2×2 interpolationsfrei hochskaliert)]]Eine Lösung für dies, die oft genannt wird, ist, den Rahmen der Texturaddressierung in die mitte der Texel zu legen. Dazu addiert bzw. subtrahiert man von den Texturkoordinaten einen halben Texel:

<code>
u0 = (x0 + 0.5) / w
u1 = (x1 - 0.5) / w
v0 = (y0 + 0.5) / h
v1 = (y1 - 0.5) / h
</code>

Dann liegen die Ränder des angezeigten Quads genau auf der Texelmitte, es findet also keine Überblendung mit nebenanliegenden Tiles statt. Dieser Ansatz hat allerdings ein anderes Problem: Die Texturen verschwimmen schon bei einer 1:1 Abbildung, wie im Screenshot rechts zu sehen.

== Lösung 2: Rahmen hinzufügen ==

[[Datei:Texturatlas_bordered.png|frame|center|Tile mit Rahmen, welches mit den originalen Texturkoordinaten auf ein 4×4 größeres Quad gezeichnet wurde]]Man kann den ''bleeding''-Effekt auch beheben, indem man einen 1 px Rahmen um die Texturen im Atlas hinzufügt, welcher die Farbe des anliegenden Texturpixels hat (und in den Ecken eventuell eine lineare Überblendung). Obiges Bild demonstriert, dass dies das Problem löst.

Allerdings hilft diese Lösung nicht, wenn man (automatisch generierte) Mipmaps verwendet. Dafür muss man den Rahmen für jedes Mipmap-Level verdoppeln, was ab einem gewissen Mipmap-Level zu viel Platz benötigt. Oft ist es allerdings so, dass man, wenn man Mipmaps braucht (also unterschiedliche Skalierungen einer Textur anzeigen will) sowieso keine pixelgenaue Darstellung benötigt.

== Zusammenfassung ==

{|{{Prettytable_B1}} width="100%"
!Technik / Kriterium
!Kein ''bleeding''
!Pixelgenaue Darstellung bei 1:1 Rendering
!Mipmap-Kompatibilität
|-
! style="text-align:left" |Normal
|✘
|✔
|✔
|-
! style="text-align:left" |Lösung 1: Ausschnitt verkleinern
|✔
|✘
|✔
|-
! style="text-align:left" | Lösung 2: Rahmen hinzufügen
|✔
|✔
|✘
|-
|}

Texelgenaue Texturkoordinate

2014-05-27T13:04:14Z

Lord horazont: Tabellenmarkup verbessert

[[Texelgenaue Texturkoordinate|Texelgenaue Texturkoordinaten]] werden immer dann gebraucht, wenn man mehrere Bilder in einer Textur hat, z.B. bei einer Tilemap oder wenn man zur Laufzeit einen dynamischen Texturatlas erzeugt.

= Anwendungsgebiet =

[[Datei:Beispiel_Texturatlas.png|thumb|256px|Beispiel eines Texturatlas. Unterschiedliche Texturen sind in einem Bild untergebracht.]]

Ein häufiges Anwendungsgebiet ist wie schon erwähnt das Addressieren von Texturen in einem Texturatlas. Dazu muss man Pixelgenau die einzelnen Teilbilder herausschneiden, um sie auf Objekten anzubringen.

Wenn der Ausschnitt die Pixel im Rechteck ''x0..x1'', ''y0..y1'' abdeckt, dann ist die intuitive Methode um die Texturkoordinaten ''u0,u1,v0,v1'' für eine Textur der Breite ''w'' und Höhe ''h'' zu erhalten:

<code>
u0 = x0 / w
u1 = x1 / w
v0 = y0 / h
v1 = y1 / h
</code>

= Problematik =

Diese Koordinaten bergen allerdings Probleme in sich, sobald man einen anderen Texturfilter als [[glTexParameter#Vergleich_zwischen_verschiedenen_Texturfilter|GL_NEAREST]] verwendet und die Texel nicht 1:1 auf Pixel übertragen werden (also irgendeine Form der Skalierung der Textur statt findet).

[[Datei:Texturatlas_bleeding.png|frame|center|Ein Tile mit den obigen Texturkoordinaten auf ein 4×4 größeres Quad gezeichnet]] Dann kommt es zu ''bleeding''-Effekten, bei denen die nebenanliegenden Texturen in das gewollte Bild reinblenden. In dem Beispiel oben wurde das zweite Tile von links ganz unten (64 px×64 px) auf ein Quad welches mit 256 px×256 px gerendert wurde mit GL_LINEAR aufgebracht. Man kann deutlich erkennen wie die nebenanliegenden Tiles in das Tile hineinbleeden.

== Lösung 1: Texturaddressierung verändern ==

[[Datei:Texturatlas_offsetcoords.png|frame|Tile welches mit den links stehenden Koordinaten auf ein gleich großes Quad gezeichnet wurde (Screenshot um Faktor 2×2 interpolationsfrei hochskaliert)]]Eine Lösung für dies, die oft genannt wird, ist, den Rahmen der Texturaddressierung in die mitte der Texel zu legen. Dazu addiert bzw. subtrahiert man von den Texturkoordinaten einen halben Texel:

<code>
u0 = (x0 + 0.5) / w
u1 = (x1 - 0.5) / w
v0 = (y0 + 0.5) / h
v1 = (y1 - 0.5) / h
</code>

Dann liegen die Ränder des angezeigten Quads genau auf der Texelmitte, es findet also keine Überblendung mit nebenanliegenden Tiles statt. Dieser Ansatz hat allerdings ein anderes Problem: Die Texturen verschwimmen schon bei einer 1:1 Abbildung, wie im Screenshot rechts zu sehen.

== Lösung 2: Rahmen hinzufügen ==

[[Datei:Texturatlas_bordered.png|frame|center|Tile mit Rahmen, welches mit den originalen Texturkoordinaten auf ein 4×4 größeres Quad gezeichnet wurde]]Man kann den ''bleeding''-Effekt auch beheben, indem man einen 1 px Rahmen um die Texturen im Atlas hinzufügt, welcher die Farbe des anliegenden Texturpixels hat (und in den Ecken eventuell eine lineare Überblendung). Obiges Bild demonstriert, dass dies das Problem löst.

Allerdings hilft diese Lösung nicht, wenn man (automatisch generierte) Mipmaps verwendet. Dafür muss man den Rahmen für jedes Mipmap-Level verdoppeln, was ab einem gewissen Mipmap-Level zu viel Platz benötigt. Oft ist es allerdings so, dass man, wenn man Mipmaps braucht (also unterschiedliche Skalierungen einer Textur anzeigen will) sowieso keine pixelgenaue Darstellung benötigt.

== Zusammenfassung ==

{|{{Prettytable_B1}} width="100%"
!Technik / Kriterium
!Kein ''bleeding''
!Pixelgenaue Darstellung bei 1:1 Rendering
!Mipmap-Kompatibilität
|-
! style="text-align:left" |Normal
|✘
|✔
|✔
|-
! style="text-align:left" |Lösung 1: Ausschnitt verkleinern
|✔
|✘
|✔
|-
! style="text-align:left" | Lösung 2: Rahmen hinzufügen
|✔
|✔
|✘
|-
|}

Texelgenaue Texturkoordinate

2014-05-27T13:02:45Z

Lord horazont: Überschriften-Markup repariert

[[Texelgenaue Texturkoordinate|Texelgenaue Texturkoordinaten]] werden immer dann gebraucht, wenn man mehrere Bilder in einer Textur hat, z.B. bei einer Tilemap oder wenn man zur Laufzeit einen dynamischen Texturatlas erzeugt.

= Anwendungsgebiet =

[[Datei:Beispiel_Texturatlas.png|thumb|256px|Beispiel eines Texturatlas. Unterschiedliche Texturen sind in einem Bild untergebracht.]]

Ein häufiges Anwendungsgebiet ist wie schon erwähnt das Addressieren von Texturen in einem Texturatlas. Dazu muss man Pixelgenau die einzelnen Teilbilder herausschneiden, um sie auf Objekten anzubringen.

Wenn der Ausschnitt die Pixel im Rechteck ''x0..x1'', ''y0..y1'' abdeckt, dann ist die intuitive Methode um die Texturkoordinaten ''u0,u1,v0,v1'' für eine Textur der Breite ''w'' und Höhe ''h'' zu erhalten:

<code>
u0 = x0 / w
u1 = x1 / w
v0 = y0 / h
v1 = y1 / h
</code>

= Problematik =

Diese Koordinaten bergen allerdings Probleme in sich, sobald man einen anderen Texturfilter als [[glTexParameter#Vergleich_zwischen_verschiedenen_Texturfilter|GL_NEAREST]] verwendet und die Texel nicht 1:1 auf Pixel übertragen werden (also irgendeine Form der Skalierung der Textur statt findet).

[[Datei:Texturatlas_bleeding.png|frame|center|Ein Tile mit den obigen Texturkoordinaten auf ein 4×4 größeres Quad gezeichnet]] Dann kommt es zu ''bleeding''-Effekten, bei denen die nebenanliegenden Texturen in das gewollte Bild reinblenden. In dem Beispiel oben wurde das zweite Tile von links ganz unten (64 px×64 px) auf ein Quad welches mit 256 px×256 px gerendert wurde mit GL_LINEAR aufgebracht. Man kann deutlich erkennen wie die nebenanliegenden Tiles in das Tile hineinbleeden.

== Lösung 1: Texturaddressierung verändern ==

[[Datei:Texturatlas_offsetcoords.png|frame|Tile welches mit den links stehenden Koordinaten auf ein gleich großes Quad gezeichnet wurde (Screenshot um Faktor 2×2 interpolationsfrei hochskaliert)]]Eine Lösung für dies, die oft genannt wird, ist, den Rahmen der Texturaddressierung in die mitte der Texel zu legen. Dazu addiert bzw. subtrahiert man von den Texturkoordinaten einen halben Texel:

<code>
u0 = (x0 + 0.5) / w
u1 = (x1 - 0.5) / w
v0 = (y0 + 0.5) / h
v1 = (y1 - 0.5) / h
</code>

Dann liegen die Ränder des angezeigten Quads genau auf der Texelmitte, es findet also keine Überblendung mit nebenanliegenden Tiles statt. Dieser Ansatz hat allerdings ein anderes Problem: Die Texturen verschwimmen schon bei einer 1:1 Abbildung, wie im Screenshot rechts zu sehen.

== Lösung 2: Rahmen hinzufügen ==

[[Datei:Texturatlas_bordered.png|frame|center|Tile mit Rahmen, welches mit den originalen Texturkoordinaten auf ein 4×4 größeres Quad gezeichnet wurde]]Man kann den ''bleeding''-Effekt auch beheben, indem man einen 1 px Rahmen um die Texturen im Atlas hinzufügt, welcher die Farbe des anliegenden Texturpixels hat (und in den Ecken eventuell eine lineare Überblendung). Obiges Bild demonstriert, dass dies das Problem löst.

Allerdings hilft diese Lösung nicht, wenn man (automatisch generierte) Mipmaps verwendet. Dafür muss man den Rahmen für jedes Mipmap-Level verdoppeln, was ab einem gewissen Mipmap-Level zu viel Platz benötigt. Oft ist es allerdings so, dass man, wenn man Mipmaps braucht (also unterschiedliche Skalierungen einer Textur anzeigen will) sowieso keine pixelgenaue Darstellung benötigt.

== Zusammenfassung ==

{|{{Prettytable_B1}} width="100%"
!Kriterium
!Kein ''bleeding''
!Pixelgenaue Darstellung bei 1:1 Rendering
!Mipmap-Kompatibilität
|-
|Normal
|✘
|✔
|✔
|-
|Lösung 1: Ausschnitt verkleinern
|✔
|✘
|✔
|-
|Lösung 2: Rahmen hinzufügen
|✔
|✔
|✘
|-
|}

Texelgenaue Texturkoordinate

2014-05-27T13:00:42Z

Lord horazont: Die Seite wurde neu angelegt: „Texelgenaue Texturkoordinaten werden immer dann gebraucht, wenn man mehrere Bilder in einer Textur hat, z.B. bei einer Tilemap…“

[[Texelgenaue Texturkoordinate|Texelgenaue Texturkoordinaten]] werden immer dann gebraucht, wenn man mehrere Bilder in einer Textur hat, z.B. bei einer Tilemap oder wenn man zur Laufzeit einen dynamischen Texturatlas erzeugt.

=== Anwendungsgebiet ===

[[Datei:Beispiel_Texturatlas.png|thumb|256px|Beispiel eines Texturatlas. Unterschiedliche Texturen sind in einem Bild untergebracht.]]

Ein häufiges Anwendungsgebiet ist wie schon erwähnt das Addressieren von Texturen in einem Texturatlas. Dazu muss man Pixelgenau die einzelnen Teilbilder herausschneiden, um sie auf Objekten anzubringen.

Wenn der Ausschnitt die Pixel im Rechteck ''x0..x1'', ''y0..y1'' abdeckt, dann ist die intuitive Methode um die Texturkoordinaten ''u0,u1,v0,v1'' für eine Textur der Breite ''w'' und Höhe ''h'' zu erhalten:

<code>
u0 = x0 / w
u1 = x1 / w
v0 = y0 / h
v1 = y1 / h
</code>

=== Problematik ===

Diese Koordinaten bergen allerdings Probleme in sich, sobald man einen anderen Texturfilter als [[glTexParameter#Vergleich_zwischen_verschiedenen_Texturfilter|GL_NEAREST]] verwendet und die Texel nicht 1:1 auf Pixel übertragen werden (also irgendeine Form der Skalierung der Textur statt findet).

[[Datei:Texturatlas_bleeding.png|frame|center|Ein Tile mit den obigen Texturkoordinaten auf ein 4×4 größeres Quad gezeichnet]] Dann kommt es zu ''bleeding''-Effekten, bei denen die nebenanliegenden Texturen in das gewollte Bild reinblenden. In dem Beispiel oben wurde das zweite Tile von links ganz unten (64 px×64 px) auf ein Quad welches mit 256 px×256 px gerendert wurde mit GL_LINEAR aufgebracht. Man kann deutlich erkennen wie die nebenanliegenden Tiles in das Tile hineinbleeden.

== Lösung 1: Texturaddressierung verändern ==

[[Datei:Texturatlas_offsetcoords.png|frame|Tile welches mit den links stehenden Koordinaten auf ein gleich großes Quad gezeichnet wurde (Screenshot um Faktor 2×2 interpolationsfrei hochskaliert)]]Eine Lösung für dies, die oft genannt wird, ist, den Rahmen der Texturaddressierung in die mitte der Texel zu legen. Dazu addiert bzw. subtrahiert man von den Texturkoordinaten einen halben Texel:

<code>
u0 = (x0 + 0.5) / w
u1 = (x1 - 0.5) / w
v0 = (y0 + 0.5) / h
v1 = (y1 - 0.5) / h
</code>

Dann liegen die Ränder des angezeigten Quads genau auf der Texelmitte, es findet also keine Überblendung mit nebenanliegenden Tiles statt. Dieser Ansatz hat allerdings ein anderes Problem: Die Texturen verschwimmen schon bei einer 1:1 Abbildung, wie im Screenshot rechts zu sehen.

== Lösung 2: Rahmen hinzufügen ==

[[Datei:Texturatlas_bordered.png|frame|center|Tile mit Rahmen, welches mit den originalen Texturkoordinaten auf ein 4×4 größeres Quad gezeichnet wurde]]Man kann den ''bleeding''-Effekt auch beheben, indem man einen 1 px Rahmen um die Texturen im Atlas hinzufügt, welcher die Farbe des anliegenden Texturpixels hat (und in den Ecken eventuell eine lineare Überblendung). Obiges Bild demonstriert, dass dies das Problem löst.

Allerdings hilft diese Lösung nicht, wenn man (automatisch generierte) Mipmaps verwendet. Dafür muss man den Rahmen für jedes Mipmap-Level verdoppeln, was ab einem gewissen Mipmap-Level zu viel Platz benötigt. Oft ist es allerdings so, dass man, wenn man Mipmaps braucht (also unterschiedliche Skalierungen einer Textur anzeigen will) sowieso keine pixelgenaue Darstellung benötigt.

== Zusammenfassung ==

{|{{Prettytable_B1}} width="100%"
!Kriterium
!Kein ''bleeding''
!Pixelgenaue Darstellung bei 1:1 Rendering
!Mipmap-Kompatibilität
|-
|Normal
|✘
|✔
|✔
|-
|Lösung 1: Ausschnitt verkleinern
|✔
|✘
|✔
|-
|Lösung 2: Rahmen hinzufügen
|✔
|✔
|✘
|-
|}

Datei:Texturatlas bordered.png

2014-05-27T12:54:14Z

Lord horazont: Beispiel um Lösung mit Rahmen um die Teiltexturen bei Texturatlanten wie :Datei:Beispiel_Texturatlas.png zu demonstrieren.

Beispiel um Lösung mit Rahmen um die Teiltexturen bei Texturatlanten wie [[:Datei:Beispiel_Texturatlas.png]] zu demonstrieren.

Datei:Texturatlas bleeding.png

2014-05-27T12:53:24Z

Lord horazont: Link repariert

Zeigt das Bleeding bei linearer Interpolation einem Texturatlas wie in [[:Datei:Beispiel_Texturatlas.png]].

Datei:Texturatlas offsetcoords.png

2014-05-27T12:53:01Z

Lord horazont: Link repariert

Beispiel um Problem mit verschobenen Koordinaten bei Texturatlanten wie [[:Datei:Beispiel_Texturatlas.png]] zu demonstrieren.

Datei:Texturatlas offsetcoords.png

2014-05-27T12:47:54Z

Lord horazont: Lord horazont lud eine neue Version von „Datei:Texturatlas offsetcoords.png“ hoch

Beispiel um Problem mit verschobenen Koordinaten bei Texturatlanten wie [[Datei:Beispiel_Texturatlas.png]] zu demonstrieren.

Datei:Texturatlas offsetcoords.png

2014-05-27T12:37:00Z

Lord horazont: Beispiel um Problem mit verschobenen Koordinaten bei Texturatlanten wie Datei:Beispiel_Texturatlas.png zu demonstrieren.

Beispiel um Problem mit verschobenen Koordinaten bei Texturatlanten wie [[Datei:Beispiel_Texturatlas.png]] zu demonstrieren.

Datei:Texturatlas bleeding.png

2014-05-27T12:36:19Z

Lord horazont: Zeigt das Bleeding bei linearer Interpolation einem Texturatlas wie in Datei:Beispiel_Texturatlas.png.

Zeigt das Bleeding bei linearer Interpolation einem Texturatlas wie in [[Datei:Beispiel_Texturatlas.png]].

Datei:Beispiel Texturatlas.png

2014-05-27T12:35:30Z

Lord horazont: Lord horazont lud eine neue Version von „Datei:Beispiel Texturatlas.png“ hoch

Selbst hergestellt aus Blender Renderings. Verwendbar unter der [https://creativecommons.org/licenses/by-nc-sa/4.0/ CC-BY-NC-SA] Lizenz.

Datei:Beispiel Texturatlas.png

2014-05-27T12:25:13Z

Lord horazont: Lord horazont lud eine neue Version von „Datei:Beispiel Texturatlas.png“ hoch

Selbst hergestellt aus Blender Renderings. Verwendbar unter der [https://creativecommons.org/licenses/by-nc-sa/4.0/ CC-BY-NC-SA] Lizenz.

Datei:Beispiel Texturatlas.png

2014-05-27T12:16:40Z

Lord horazont: Lizenzlink repariert

Selbst hergestellt aus Blender Renderings. Verwendbar unter der [https://creativecommons.org/licenses/by-nc-sa/4.0/ CC-BY-NC-SA] Lizenz.

Datei:Beispiel Texturatlas.png

2014-05-27T12:15:48Z

Lord horazont: Selbst hergestellt aus Blender Renderings. Verwendbar unter CC-BY-NC-SA

Selbst hergestellt aus Blender Renderings. Verwendbar unter [[https://creativecommons.org/licenses/by-nc-sa/4.0/|CC-BY-NC-SA]]

Hilfe:Bearbeiten

2013-10-12T17:03:59Z

Lord horazont: Weiterleitung auf Hilfe:Bearbeitungshilfe erstellt

#REDIRECT [[Hilfe:Bearbeitungshilfe]]

DGL Treffen/2013/Organisation

2013-09-28T09:58:34Z

Lord horazont: /* Wer kommt mit? */

Es wurde einmal mehr vorgeschlagen sich im Sommer zu treffen. Ort ist diesmal bei Kassel.

Weitere Infos und detaillierte Besprechungen finden in [http://delphigl.com/forum/viewtopic.php?f=4&t=10746 diesem Forenthread] statt.

==Wo?==
'''Kassel'''<br>
[http://www.fewo-direkt.de/ferienwohnung-ferienhaus/p549290 Ferienwohnungen], <br>
Im Teich 5 <br/>
34314 Espenau

==Wann?==
*Anreise: Sa 28.09.2013
*Abreise: Mo 07.10.2013

==Was kostet das?==
Für die Übernachter ca 20Eur pro Nacht plus Nahrung.
Für Ausflüge, Museen etc in Kassel ca. 20-30Eur
Die Anreise ist, wie üblich, von den Teilnehmern zu tragen. Allerdings versuchen wir natürlich beides zu optimieren d.h. Fahrgemeinschaften auf den Fahrten und Gemeinschaftskasse bei der Verpflegung.

==Wer kommt mit?==
Hier eine vorläufige Teilnehmerliste. Anzahl Betten und Schlafzimmer noch offen.
{|{{Prettytable_B1}}
!Teilnehmer
!Fest
!Bezahlt
!Tage
(10=max)
!Anreise
!Kommentar
|-
|Flash
|X
|
|10 (späte Anreise)
|PKW ab München
|(3 Plätze im PKW frei.)
|-
|i0n0s
|X
|
|10
|PKW ab Gießen
|(1 Platz im PKW frei.)
|-
|Phobeus
|x
|
|10
|PKW ab Hamburg
|(1 Platz im PKW frei.)
|-
|Lord Horazont
|
|
|3 (4.10.–6.10.)
|Zug oder so
|—
|-
|''frei''
|
|
|
|
|
|-
|Knittel
|X
|
|3 (28. - 1.)
|PKW ab Frankfurt
|3 Plätze frei
|-
!colspan="6"|Gäste (ohne Übernachtung)
|-
|''frei''
|
|
|
|
|
|-
|''frei''
|
|
|
|
|
|-
|''frei''
|
|
|
|
|
|-
|}

==Wie kommt man hin?==
Auto oder Bahn.

== Sonstiges Organisatorisches ==
In jedem Fall sollte jeder Mitfahrer eigenständig Kontakt mit mindestens seinem Fahrer aufnehmen und die genaue Anreise klären. Handynummer können an Phobeus geschickt werden. Jeder der seine Nummer preisgibt, erhält die Nummern der jeweilig Anderen. Sofern also niemand damit bedenken hat, sollte davon gebrauch machen. Das letzte Mal hatten lediglich die Fahrer die Nummern untereinander, was unglücklich ist, da gerade diese am Steuer sitzen ;)

==Was muss man mitbringen?==
===1x für Alle===
* Küchenequipement (Gewürze, Dosenöffner/Korkenzieher/Flaschenöffner, Kaffeefilter, Geschirrtücher, Wischtücher, Küchenrolle, Spülmittel)
* Klopapier
* 1 Router
* Netzwerkkabel (1x für alle? Ich weiß ja net... *g*)
* Was W-Lan Router mäßiges wäre suuuuper! Ist aber kein muss
* Cocktail Zeug!

===Jeder===
* Das [[DGL Shirt]] - wer eins hat!
* Bargeld (Kaution (siehe Forum) + Reisekasse)
* Bettwäsche!
* Handtücher!
* Wechsel-Kleidung (Waschmaschine ist vorhanden)
* Nahrungsmittel (Es wird aber auch zentral, vor Grenzübertritt, eingekauft)
* Reisedokumente (Führerschein, Personalausweis, Versicherungs und Geldkarten)
* Reiseapotheke
* Hygieneartikel
* Badesachen!
* Elektronik (Laptop, Fotoapparat, Tanzmatten, MEHRFACHSTECKDOSEN!)
* Sonstiges (was zu lesen, Schreibzeug etc.)
''zu klären''

==Was gibts zu erleben?==
*DGLer in echt ;)
*Grillen
*Eine Minni-LAN
*Videoabende
*Live Projektvorstellung
*Umgebung erkunden

==Nahrungsmittel==
Was muss für Sonntag usw besorgt werden (macht Flash):
- Cocktailzeug & Crushed Ice (Flash & i0n0s)
- Knabberzeug (Knittel)
- ''Abendessen???''

glTexSubImage2D

2013-03-05T15:32:56Z

Lord horazont: /* Parameter */ Falsche Beschreibung von pixels repariert

= glTexSubImage2D =

== Name ==
'''glTexSubImage2D''' - Legt ein zweidimensionales Subimage fest.

== Delphi-Spezifikation ==

procedure '''glTexSubImage2D'''(''target'' : GLenum;
''level'' : GLint;
''xoffset'' : GLint; ''yoffset'' : GLint;
''width'' : GLsizei; ''height'' : GLsizei;
''format'' : GLenum; ''type'' : GLenum;
''pixels'' : '''const''' ^GLvoid)

== Parameter ==

{| border="1" rules="all"
! ''target''
| Gibt die Zieltextur an. Muss '''GL_TEXTURE_2D''' sein.
|-
! ''level''
| Gibt die [[LOD]]-Nummer an. Level 0 ist die Standardtextur. Level ''n'' ist die ''n''-te Mipmap-Textur.
|-
! ''xoffset''
| Gibt den Texel-Offset-Wert innerhalb des Texturarrays in x-Richtung an.
|-
! ''yoffset''
| Gibt den Texel-Offset-Wert innerhalb des Texturarrays in y-Richtung an.
|-
! ''width''
| Gibt die Breite des Subimages an.
|-
! ''height''
| Gibt die Höhe des Subimages an.
|-
! ''format''
| Gibt das Format der Pixeldaten an. Die folgenden Werte sind erlaubt:
'''GL_COLOR_INDEX''', '''GL_RED''', '''GL_GREEN''', '''GL_BLUE''', '''GL_ALPHA''', '''GL_RGB''', '''GL_BGR''', '''GL_RGBA''', '''GL_BGRA''', '''GL_LUMINANCE''' und '''GL_LUMINANCE_ALPHA'''.
|-
! ''type''
| Gibt den Datentyp der Pixeldaten an. Die folgenden Werte sind erlaubt:
'''GL_BITMAP, GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2_EXT, GL_UNSIGNED_BYTE_2_3_3_REV_EXT, GL_UNSIGNED_SHORT_5_6_5_EXT, GL_UNSIGNED_SHORT_5_6_5_REV_EXT, GL_UNSIGNED_SHORT_4_4_4_4_EXT, GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT, GL_UNSIGNED_SHORT_5_5_5_1_EXT, GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT, GL_UNSIGNED_INT_8_8_8_8_EXT, GL_UNSIGNED_INT_8_8_8_8_REV_EXT, GL_UNSIGNED_INT_10_10_10_2_EXT''' und '''GL_UNSIGNED_INT_2_10_10_10_REV_EXT'''.
|-
! ''pixels''
| Pointer zu den zu transferierenden Bilddaten im Speicher
|-
|}

== Beschreibung ==
Texturierung mapt festgelegte Teile einer angegebenen Textur auf jedes graphische Primitiv für das Texturierung aktiviert ist. Um zweidimensionales Texturieren zu aktivieren bzw. zu deaktivieren, rufe man [[glEnable]] bzw. [[glDisable]] mit dem Argument '''GL_TEXTURE_2D''' auf.

[[glTexSubImage2D]] definiert einen Teil einer vorliegenden zweidimensionalen Textur neu.

Die Texel, die durch ''pixels'' angegeben werden, ersetzen den Teil des vorliegenden Textur-Arrays mit den Positionen x bei ''xoffset'' bis ''xoffset + width - 1'' und y bei ''yoffset'' bis ''yoffset + height - 1''. Dieser Bereich muss nicht alle Texel enthalten, die im ursprünglichen Texturarray lagen. Es ist nicht falsch wenn man eine Sub-Textur mit einer Breite (oder Höhe) von 0 festlegt, aber das hat keinen Effekt.<br>

== Hinweise ==
[[glTexSubImage2D]] wird nur ab der OpenGL-Version 1.1 oder höher unterstützt.<br>
<br>
Texturierung hat keinen Effekt, wenn man sich im Colorindex-Modus befindet.<br>
<br>
[[glPixelStore]] und [[glPixelTransfer]] beeinflussen die Texturen genauso, wie sie es bei [[glDrawPixels]] tun.<br>
<br>
Die Formate '''GL_BGR''' und '''GL_BGRA''' und die Typen '''GL_UNSIGNED_BYTE_3_3_2''', '''GL_UNSIGNED_BYTE_2_3_3_REV''', '''GL_UNSIGNED_SHORT_5_6_5''', '''GL_UNSIGNED_SHORT_5_6_5_REV''', '''GL_UNSIGNED_SHORT_4_4_4_4''', '''GL_UNSIGNED_SHORT_4_4_4_4_REV''', '''GL_UNSIGNED_SHORT_5_5_5_1''', '''GL_UNSIGNED_SHORT_1_5_5_5_REV''', '''GL_UNSIGNED_INT_8_8_8_8''', '''GL_UNSIGNED_INT_8_8_8_8_REV''', '''GL_UNSIGNED_INT_10_10_10_2''' und '''GL_UNSIGNED_INT_2_10_10_10_REV''' sind nur verfügbar, wenn die OpenGL-Version 1.2 oder höher ist.<br>
<br>
Wenn die '''GL_ARB_multitexture'''-Extension unterstützt wird, dann legt [[glTexSubImage2D]] eine zweidimensionale Subtextur für die aktuelle Textureinheit - angegeben mit [[glActiveMultiTextureARB]] - fest.<br>
<br>
Wenn die ''GL_ARB_imaging'''-Extension unterstützt wird, dann müssen die RGBA-Pixel, die in ''pixels'' angesteuert werden, durch die Imaging-Pipeline verarbeitetet werden. Siehe dazu [[glTexImage2D]].<br>

== Fehlermeldungen ==
'''GL_INVALID_ENUM''' wird generiert, wenn ''target'' nicht vom Typ '''GL_TEXTURE_2D''' ist.
<br>

'''GL_INVALID_OPERATION''' wird generiert, wenn das Textur-Array nicht durch eine vorhergehende [[glTexImage2D]]-Ausführung erzeugt wurde.<br>

'''GL_INVALID_VALUE''' wird generiert, wenn ''level'' kleiner 0 ist.<br>

'''GL_INVALID_VALUE''' könnte generiert werden wenn ''level'' größer als [[Bild:Log_2_max.png]] ist, wobei ''max'' der Wert von '''GL_MAX_TEXTURE_SIZE''' ist. <br>

'''GL_INVALID_VALUE''' wird generiert wenn einer der folgenden Fälle eintritt:
:*[[Bild:Xoffset_b.png]]
:*[[Bild:Xoffset_width.png]]
:*[[Bild:Yoffset_b.png]]
:*[[Bild:Yoffset_lheight.png]]

:wobei gilt:
:*w ist '''GL_TEXTURE_WIDTH''',
:*h ist '''GL_TEXTURE_HEIGHT''',
:*b ist die Randbreite (border width, '''GL_TEXTURE_BORDER''') des Texturbildes was modifiziert wird,
:*l ist 2 wenn '''GL_INTERLACE_EXT''' aktiviert wurde.
:*w und h enthalten die doppelte Randbreite.

'''GL_INVALID_VALUE''' wird generiert, wenn ''width'' oder ''height'' kleiner als 0 ist.<br>

'''GL_INVALID_ENUM''' wird generiert, wenn ''format'' keine akzeptable Konstante zugewiesen ist.<br>

'''GL_INVALID_ENUM''' wird generiert, wenn ''type'' keine akzeptable Konstante zugewiesen ist.<br>

'''GL_INVALID_ENUM''' wird generiert, wenn ''type'' '''GL_BITMAP''' und ''format'' nicht '''GL_COLOR_INDEX''' ist.<br>

'''GL_INVALID_OPERATION''' wird generiert, wenn glTexSubImage2D innerhalb eines [[glBegin]]-[[glEnd]] Blocks aufgerufen wird. <br>

'''GL_INVALID_OPERATION''' wird generiert, wenn ''type'' nicht '''GL_UNSIGNED_BYTE_3_3_2''', '''GL_UNSIGNED_BYTE_2_3_3_REV''', '''GL_UNSIGNED_SHORT_5_6_5''' oder '''GL_UNSIGNED_SHORT_5_6_5_REV''' und ''format'' nicht '''GL_RGB''' ist.<br>

'''GL_INVALID_OPERATION''' wird generiert, wenn ''type'' '''GL_UNSIGNED_SHORT_4_4_4_4''', '''GL_UNSIGNED_SHORT_4_4_4_4_REV''', '''GL_UNSIGNED_SHORT_5_5_5_1''', '''GL_UNSIGNED_SHORT_1_5_5_5_REV''', '''GL_UNSIGNED_INT_8_8_8_8''', '''GL_UNSIGNED_INT_8_8_8_8_REV''', '''GL_UNSIGNED_INT_10_10_10_2''' oder '''GL_UNSIGNED_INT_2_10_10_10_REV''' und ''format'' weder '''GL_RGBA''' noch '''GL_BGRA''' ist.

== Zugehörige Wertrückgaben ==
[[glGetTexImage]]<br>
[[glIsEnabled]] mit Token [[glIsEnabled#GL_TEXTURE_1D|GL_TEXTURE_1D]]

== Siehe auch ==
[[glCopyTexImage1D]], [[glCopyTexImage2D]], [[glCopyTexSubImage1D]], [[glCopyTexSubImage2D]], [[glDrawPixels]], [[glEnable]], [[glFog]], [[glGetTexImage]], [[glIsEnabled]], [[glPixelStore]], [[glPixelTransfer]], [[glTexEnv]], [[glTexGen]], [[glTexImage1D]], [[glTexImage2D]], [[glTexSubImage1D]], [[glTexSubImage3D]], [[glTexImage2D]], [[glTexParameter]]

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

Link

2012-05-20T13:32:54Z

Lord horazont: /* Allgemein */ Titel gesetzt

Diese Linksammlung soll allgemeine Links zu unterschiedlichen Themen bieten, die mit der Multimediaentwicklung zu tun haben.
{{Hinweis|Vielleicht ist eine Zusammenführung mit [[Tool]] sinnvoll!}}
{{Hinweis|Vielleicht ist eine Aufteilung in Unterseiten sinnvoll (möglicherweise mit Kategorien)}}

= Entwicklung mit OpenGL =

== Hardwareinfos ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://web.archive.org/web/20090417044334/http://delphi3d.net/hardware/listreports.php OpenGL Hardware Registry - Hardwareübersicht]
|{{Englisch}}
|Eine Datenbank aller Grafikkarten die in der Harware Registry vorhanden sind. Die einzelnen Artikel enthalten Infos darüber, welche Extensions von der Grafikkarte unterstützt werden.
|-
|[http://web.archive.org/web/20090506094005/http://delphi3d.net/hardware/ OpenGL Hardware Registry - Extensionübersicht]
|{{Englisch}}
|Eine Datenbank aller Extensions die in der Harware Registry vorhanden sind. Die einzelnen Artikel enthalten Infos darüber, welche Grafikkarten die entsprechende Extension unterstützen.
|-
|}


== Tutorials ==

{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
||[[Tutorial|DGL Wiki - Tutorial]]
|{{Deutsch}}
|DelphiGL.com ist Betreiber dieses Wikis und stellt eine Vielzahl Tutorials mit Schwehrpunkt OpenGL zur Verfügung.
Neben Tutorials für Einsteiger und OpenGL Anfänger gibt es auch fortgeschrittene Themen wie Shader oder Partikelsysteme.Sprache der Wahl ist hier Delphi.
|-
|[http://www.joachimrohde.com/cms/xoops/modules/articles/index.php?cat_id=1 joachimrohde.com]
|{{Deutsch}}
|Auf dieser Seite findet ihr deutsche Übersetzungen der bekannten NeHe Tutorials. Sprache der Wahl ist hier C++.
|-
|[http://www.cg.tuwien.ac.at/studentwork/VRSem96/OpenGL/ Technische Universität Wien]
|{{Deutsch}}
|Diese Seite bietet einen allgemeinen Überblick über die primären Funktionen von OpenGL und richtet sich vor allem an Einsteiger.
|-
|[http://nehe.gamedev.net/ Nehe]
|{{Englisch}}
|Die berühmt berüchtigten NeHe Tutorials sind eine umfangreiche Sammlung an Tutorials zum Thema OpenGL. Von Anfängertutorials bis hin zu komplexen Effekten wird alles behandelt. Sprache der Wahl ist hier C++. (Eine Übersetzung der NeHe Tutorials findet ihr bei Joachim Rhode (siehe oben). )
|-
|[http://www.sulaco.co.za/tut.htm sulaco.co.za]
|{{Englisch}}
| OpenGL Beispiele in Delphi
|}

== OpenGL Funktionen ==

=== GL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GL|DGL Wiki - Kategorie GL]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten OpenGL Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL.tar.gz OpenGL.org - Original Spezifkationen]
|{{Englisch}}
|Die Originalspezifikationen der OpenGL 1.0 und OpenGL 1.1 Befehle. (Diese HTML-Dokumente sind nicht Copy&Paste freundlich, da sie vermutlich automatisch aus vorhandenen Dateien (Postscript) erzeugt wurden.)
|-
|[http://developer.3dlabs.com/documents/glmanpage_index.htm 3dLabs]
|{{Englisch}}
|Die Originalspezifikationen der OpenGL 1.0 und OpenGL 1.1 Befehle.
|-
|[http://web.archive.org/web/20040616082839/http://www.mevis.de/~uwe/opengl/opengl.html mevis.de]
|{{Englisch}}
|Sammlung von Englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|[http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/glfunc01_4f03.asp MSDN von Microsoft]
|{{Englisch}}
|OpenGL Dokumentation in der MSDN. Die Erklärung der MSDN sind meist keine reinen Kopien der Originalspezifikationen, sondern enthalten hin und wieder auch zusätzliche Informationen, oder formulieren Texte auf verständlichere Art und Weise.
|-
|}

=== GLU ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GLU|DGL Wiki - Kategorie GLU]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten GLU Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/glu/ OpenGL.org - Original Spezifkationen]
|{{Englisch}}
|Originalspezifikationen für die GLU Befehle. (Diese HTML-Dokumente sind nicht Copy&Paste freundlich, da sie vermutlich automatisch aus vorhandenen Dateien (Postscript) erzeugt wurden.)
|-
|[http://web.archive.org/web/20040616082839/http://www.mevis.de/~uwe/opengl/opengl.html mevis.de mevis.de]
|{{Englisch}}
|Sammlung von englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|[http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/glufnc01_0e43.asp MSDN von Microsoft]
|{{Englisch}}
|GLU Dokumentation in der MSDN. Die Erklärung der MSDN sind meist keine reinen Kopien der Originalspezifikationen, sondern enthalten hin und wieder auch zusätzliche Informationen, oder formulieren Texte auf verständlichere Art und Weise.
|-
|}

=== GLX ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GLX|DGL Wiki - Kategorie GLX]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten GLX Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/glx/ OpenGL.org - Original Spezifkationen]
|{{Englisch}}
|Orgninalspezifikationen der GLX Befehle bei OpenGL.org.
|-
|[http://web.archive.org/web/20040616082839/http://www.mevis.de/~uwe/opengl/opengl.html mevis.de mevis.de]
|{{Englisch}}
|Sammlung von Englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|}

=== WGL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:WGL|DGL Wiki - Kategorie WGL]]
|{{Deutsch}}
|Wiki-Kategorie die alle übersetzten WGL Befehle enthält.
|-
|[http://web.archive.org/web/20071218151417/http://developer.3dlabs.com/documents/wglmanpage_index.htm 3dLabs]
|{{Englisch}}
|Sammlung einiger WGL Befehlsspezifikationen.
|-
|}

=== GLUT ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://freeglut.sourceforge.net/docs/api.php The freeglut Projekt]
|{{Englisch}}
|Englischsprachige Dokumentation zum OpenGL Utility Toolkit kurz GLUT.
|-
|}

=== SDL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:SDL|DGL Wiki - Kategorie SDL]]
|{{Deutsch}}
|Übersicht aller auf die SDL bezogenen Artikel hier im Wiki. Darunter befinden sich eine Vielzahl von Übersetzungen der SDL Befehlspezifikationen. Diese können auch in der [[SDL-Funktionsübersicht]] gefunden werden.
|-
|[http://www.libsdl.org/cgi/docwiki.cgi/SDL_20API libsdl.org]
|{{Englisch}}
|Das Dokumentationswiki von libSDL.org enthält die komplette Dokumenation zur SDL in englischer Sprache.
|-
|-
|[http://www.freepascal-meets-sdl.net/ freepascal meets sdl]
|{{Englisch}}
| Eine Webseite die speziell Informationen über die Programmierung von SDL unter Freepascal zur Verfügung stellt.
|-
|}

== FAQs ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[FAQ| DGL Wiki - FAQ]]
|{{Deutsch}}
|Ein FAQ (Frequently Asked Questions = Häufig gestellte Fragen) zu DelphiGL.com und dem DGL Wiki.
|-
|[http://www.3dsource.de/faq/index.htm 3dsource.de]
|{{Deutsch}}
|Ein FAQ zu Fragen rund um OpenGL.
|-
|}

== Effekte und Techniken mit OpenGL ==

===Glow===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamasutra.com/view/feature/2107/realtime_glow.php Gamasutra]
|{{Englisch}}
|Beschreibt, wie man mit Hilfe von Shader(hier DirectX Shader) den Gloweffekt in Realtime umsetzt. Dabei wird erst die Technik dahinter erklärt, und dann wie man sie Schritt für Schritt umsetzt.
|-
|[http://web.archive.org/web/20071118043007/http://collective.valve-erc.com/index.php?go=tron1 valve-erc.com]
|{{Englisch}}
|Schritt für Schritt Anleitung, wie man mit Hilfe von Cg in OpenGL den Glow Effekt realisieren kann
|-
|}

===HDR===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://web.archive.org/web/20090601052809/http://www.gamedev.net/columns/hardcore/hdrrendering/ gamedev.net]
|{{Englisch}}
|Hier wird sehr kurz eingeleitet, was HDR Rendering überhaupt ist, dann wird der Aufbau des *.hdr Formats erläutert, und dann geht es schon von 0 auf 100 zum Programmieren. Erklärungen gibt es kaum, dafür werden fertige Shader(für DirectX) geboten.
|-
|[http://web.archive.org/web/20090601202039/http://www.gamedev.net/reference/articles/article2208.asp gamedev.net]
|{{Englisch}}
|Beschreibt auch nur etwas kurz das HDR Verfahren, jedoch mit mehr mathematischen Hintergrund in Sachen Tonemapping. Beispielcode für Tonemapping in C++ liegt bei.
|-
|}

===BSP Bäume===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://web.archive.org/web/20081201115631/http://www.3dtechdev.com/tutorials/leafbsp/3dbsptrees.html 3dtechdev.com]
|{{Englisch}}
|Das beste Dokument überhaupt, für allem die selber BSP Bäume compilieren möchte. Ist belegt mit sehr viel Grafik. Erst beginnt er das Prinzip allgemein zum umschreiben, dann wird alles genau erläutert, und mit verständlichen Pseudocode untermalt.
|-
|[http://web.archive.org/web/20081019041535/http://www.3dtechdev.com/tutorials/illegalgeometry/illegalgeometrytut.html 3dtechdev.com]
|{{Englisch}}
|Nicht ganz so gut geworden, wie sein erstes Tutorial, aber erklärt auch sehr gut, wie man illegale Geometrie aufspürt und beseitigt. Wieder mit Grafiken und Pseudocodes verständlich belegt. Hiermit kann man seinem Map-Compiler den letzten Schliff verleien.
|-
|[http://www.gamedev.net/reference/articles/article981.asp Gamedev]
|{{Englisch}}
|Von Michael Abrash, dürfte der ''Erfinder'' von Quake sein. Naja, meine Englischkenntnisse reichen hier nicht ganz aus, um den Text zu verstehen. Ist etwas umständlich geschrieben. Dafür mit Grafiken unterlegt.
|-
|[http://www.zfx-online.de/Tutorials.php?ID=11 Part 1 - Allgemein]
|{{Deutsch}}
|Einzigste deutsche Referenz zu BSP Bäumen, dafür Daumen hoch. Ist aber nicht das Wahre: schlechter C Code, und ich hatte auch nicht den Einduck, das er die Theorie zu diesem Thema bis in die Tiefe verstanden hat(oder er wollte es nicht zu akademisch Erklären oO). Aber ein guter Einstieg in dieses Thema.
|-
|[http://www.zfx-online.de/Tutorials.php?ID=13 Part 2 - Kollision und PVS]
|{{Deutsch}}
|-
|[http://web.archive.org/web/20060516103821/http://www.cs.uwec.edu/~stevende/cs455/programs/GameTutorials%20-%20Quake%203%20BSP%20Format.htm Quake3 *.bsp Format]
|{{Englisch}}
|Die beste Dokumentation für das BSP Format, die ich gefunden habe, besser als den Quake3 Sourcecode zu durchforsten. Leider etwas magere Eklährung zu wichtigen Themen wie Patches(Curved Surfaces). Ich pers. hatte jetzt 1 1/2 Wochen gebraucht, um das *.bsp Format vollständig zu verstehen. Ist aber anscheinend die beste Format Dokumentation im Netz.
|-
|[http://www.flipcode.com/articles/article_q2bsp.shtml Quake2 *.bsp Format]
|{{Englisch}}
|Kann auch nur soviel sagen, wie beim Link zuvor. Es fehlen hier auch zum Teil Informationen. Man muss halt viel ausprobieren, und sich den Quake 2 Source zu Herzen nehmen, damit man es versteht.
|-
|}

===Himmel & Wolken===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamedev.net/community/forums/topic.asp?topic_id=86024 Gamedev]
|{{Englisch}}
|Guter Thread mit vielen Anregungen und Links.
|-
|[http://www.gamedev.net/community/forums/topic.asp?topic_id=135654 Gamedev]
|{{Englisch}}
|Hier wird die Diskussion zum obigen Link weitergeführt.
|-
|[http://freespace.virgin.net/hugo.elias/models/m_clouds.htm Plasma]
|{{Englisch}}
|Eine nette Idee um Plasma in Echtzeit zu generieren, und zu verändern. Leider nichts zum Shading.
|-
|[http://nis-lab.is.s.u-tokyo.ac.jp/~nis/cdrom/sig00_cloud.pdf 3D Wolken]
|{{Englisch}}
|Paper über generieren und rendern von 3 dimensionalen Wolken inklusive Schatten und Lichtstrahlen. Ich hab nur den Lichtstahlen-Algorithmus ausprobiert. Saulangsam aber sehr einfach zu implementieren. Einen Blick ist es auf jeden Fall wert.
|-
|[http://web.archive.org/web/20031011052035/http://www.geocities.com/ngdash/whitepapers/skydomecolor.html Skydome]
|{{Englisch}}
|Wenn man mal schnell gute Farben für seinen Skydome braucht...
|}

===Terrain===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.flipcode.com/articles/article_geomipmaps.shtml FlipCode]
|{{Englisch}}
|Artikel zu Geomipmaping. Zummindest hab ich es hier zum ersten mal gesehen. Und es funzt ganz gut.
|-
|[http://www.vterrain.org Virtual Terrain Project]
|{{Englisch}}
|Eine Seite mit Links und Artikeln zu allem, was etwas mit Terrainrendering zu tun hat.
|-
|}

===Sonstiges===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[Materialsammlung]]
|{{Deutsch}}
|Sammlung von gängigen Parametern für [[glMaterial]] hier im Wiki.
|-
|[http://freespace.virgin.net/hugo.elias/radiosity/radiosity.htm Radiosity]
|{{Englisch}}
|Erklärt sehr schön die Funktionsweise von Radiosity, liefert Beispielcodes und ist recht gut illustriert.
|-
|[http://web.archive.org/web/20050825110920/http://legion.gibbering.net/projectx/paper/shadow%20mapping/ Shadowmapping]
|{{Englisch}}
|Beschreibt das Trapezoidal Shadow Mapping - Verfahren für gerichte Lichter.
|-
|[http://www.flipcode.com/articles/article_generatingnames.shtml Namensgenerator]
|{{Englisch}}
|Per Zufallsgenrator Namen erzeugen, und nie wieder kreativ werden müssen.
|-
|[http://www.paulsprojects.net/tutorials/simplebump/simplebump.html Bumpmapping]
|{{Englisch}}
|Bumpmapping auf Lowend-Grakas. Damals war Bumpmapping noch was ganz tolles...
|-
|[http://www.paulsprojects.net/opengl/dpreflect/dpreflect.html Dot Product Reflect]
|{{Englisch}}
|zwar nur ne Demo, aber wenn man schon immer mal mit EMBM das Wasser aus Morrowind nachproggen wollte...
|-
|}

== Beispiele/Demos mit Quelltext ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.delphigl.de DelphiGL.de]
|{{Deutsch}}
| Hier finden sich besonders eindrucksvolle Newton Physik Demos. Meißtens sogar mit Quelltext.
|-
|[http://www.shadow3d.de.vu/ Shadow 3D]
|{{Deutsch}}
| Hier finden sich zwei Demos wie man Quake 3 Modelle lädt und eine glSlang Demo
|-
|[[Shadersammlung]] im DGL Wiki
|{{Deutsch}}
| Hier findet man freie Shadersourcen.
|-
|[http://www.humus.name Humus]
|{{Englisch}}
| Diverse eindrucksvolle Demos zu verschiedenen Techniken, häufig mit Quelltext in C (teilweise OpenGL / DirectX)
|}

== weitere Links ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www-user.tu-chemnitz.de/~pester/Lehre/CompGeo.pdf CompGeo.pdf]
|{{Deutsch}}
| Script "Einführung in die Computergeometrie" von Dr. Pester (TU-Chemnitz). Ideales Nachschlagewerk für die Mathematik die einem bei der Grafikprogrammierung so begegnet.
|-
|[http://www.robsite.de/ robsite.de]
|{{Deutsch}}
| Auf dieser riesigen Seite finden sich auch viele weitere Links über verschiedene Themen der 3D Programmierung.
|-
|[http://www.3dlinks.com/links.cfm?categoryid=3&subcategoryid=21 3dlinks.com]
|{{Englisch}}
| Diese Seite hat es sich zur Hauptaufgabe gemacht Links auf Seiten mit dem Thema 3D zu sammeln.
|-
|[http://www.two-kings.de/links.html two-kings.de]
|{{Englisch}}
| Sammlung diverser interessanter Links, vorallem auf Themen im gamedev-Forum verweisend.
|-
|[http://www.delgine.com Delgine.com]
|{{Englisch}}
| Heimat des freien 3D Modellers "DeleD", welcher in Delphi programmiert ist. Ihr findet dort auch Modellpackete, Texturpackete, Plugins und Hilfe bei der Programmierung von Delphi und OpenGL.
|}

= Spieleentwicklung =

==Allgemein==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.spieleprogrammierung.net/ Spieleprogrammierung - OpenGL - GLSL - OpenAL - KI - Animation - Spielephysik]
|{{Deutsch}}
|Auf dieser Seite findet Ihr Artikel, Tutorials und Programmbeispiele rund um das Thema Spieleprogrammierung. Programmiersprache ist hier C/C++.
|-
|[http://graphics-and-physics-framework.spieleprogrammierung.net/ OpenGL Graphics And Physics Framework]
|{{Deutsch}}
|Auf dieser Seite findet Ihr ein frei verfügbares OpenGL basiertes Grafik und Physik Framework (LGPL-Lizenz) samt zugehöriger Probammbeispiele. Programmiersprache ist hier C/C++.
|-
|[http://audio-framework.spieleprogrammierung.net/ OpenAL Audio Framework]
|{{Deutsch}}
|Auf dieser Seite findet Ihr ein frei verfügbares OpenAL Audio Framework (LGPL-Lizenz) samt zugehöriger Probammbeispiele. Unterstützt werden 3D Sounds, EFX (EAX Alternative) Reverb Effekte sowie Audio Streaming (Music and Voices). Programmiersprache ist hier C/C++.
|-
|[http://spieleentwicklung-im-web.spieleprogrammierung.net/ Spieleentwicklung im Web]
|{{Deutsch}}
|Auf dieser Seite findet Ihr Links (E-Books, Präsentationen, wissenschaftliche Arbeiten und Tutorials) zu verschiedenen Themengebieten der Spieleentwicklung.
|-
|[http://harablog.wordpress.com/2011/08/26/fast-pathfinding-via-symmetry-breaking/ Fast pathfinding via symmetry breaking]
|{{Englisch}}
|Optimierungen für A* Pfadsuche durch Ausnutzung von Symmetrien.
|-
|}

==Kopierschutz==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://inner-smile.com/nocrack.phtml Inner-Smile.com]
|{{Englisch}}
| Seite mit Gedanken zum Thema "Wie schütze ich meine Programme vor Crackern". Falls die Seite nicht erreichbar ist hat Google noch ne [http://www.google.com/search?q=cache:hpqPT5G4WB0J:www.inner-smile.com/nocrack.phtml+http://inner-smile.com/nocrack.phtml&hl=de&gl=de&ct=clnk&cd=1 Version im Archiv].
|-
|}

== Künstliche Intelligenz ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://web.archive.org/web/20080319034335/http://www.kbs.uni-hannover.de/Lehre/KI2/Presentationen/presentation9798/esprit/spieltheorie/spieltheorie.html Uni-Hannover - Spieltheorie]
|{{Deutsch}}
|Artikel über die Grundlagen von KI in Spielen.
|-
|[http://web.archive.org/web/20080927010337/http://www.robsite.de/tutorials.php?tut=ki Robsite KI-Tutorials]
|{{Deutsch}}
| Sammlung von Texten zum Thema KI in Spielen. Beispiele sind meist in C++.
|-
|[http://ai-depot.com/ AI-Depot.com]
|{{Englisch}}
| Seite die sich ausschließlich mit KI in Spielen beschäftigt.
|-
|[http://www.ai-junkie.com/links.html AI-Junkie.com]
|{{Englisch}}
|Linkseite mit vielen KI relevanten Links. Die Seite AI-Junie selbst behandelt auch viele Themen rund um KI.
|-
|[http://www.aiwisdom.com/ AIWisdom.com]
|{{Englisch}}
|Seite die sich mit KIs in Spielen beschäftigt und sich zum Ziel gesetzt hat, alle Artikel zum Thema zu finden und zu Katalogisieren. Es gibt hier auch Artikel über die KIs bestehender Spiele.
|-
|[http://www.aiguru.com/ AIGuru.com]
|{{Englisch}}
|Newsseite zum Thema KI, Künstliches Leben, Hiernforschung, Robotik, Nanotechnologie - Halt alles was Spass macht.
|-
|[http://www.generation5.org/ Generation5.org]
|{{Englisch}}
|Seite über KI, Robotik, etc. . Leider scheint die Seite Probleme zu haben regelmäßig aktualisiert zu werden. Aber zumindest sollte man einige Artikel finden. Die werden ja nicht schlecht.
|-
|[http://web.archive.org/web/20080702005527/http://www.gameai.com/ www.gameai.com]
|{{Englisch}}
|''Wurde Januar 2010 als down gemeldet. Weiss irgendwer etwas genaueres?'' Seite zum Thema KI in Spielen. Soll wohl einen gewissen Stellenwert in der AI-Szene haben.
|-
|[http://www-i1.informatik.rwth-aachen.de/~algorithmus/algo19.php Algorithmus der Woche - Informatikjahr 2006]
|{{Deutsch}}
|Vielleicht schon etwas älter aber doch eine gute Anleitung um eine einfache Schach-KI zu erstellen.
|}

= Ressourcen =
In dieser Gruppe finden sich Links um die Ressourcen für Eure Projekte zu erstellen.

== Texturen / 2D-Grafiken ==

'''Legende:'''
:'''Kostenpflichtige Seiten''' sind mit einem * zu '''kennzeichnen'''
:GPL: Kompatibel mit der GPL
:MPL: Kompatibel mit der MPL
:OSS: Verwendung in OpenSource Software nicht verboten
:CSS: Verwendung in ClosedSource Software nicht verboten
:Komm: Verwendung in kommerzieller Software nicht verboten

=== Texturen ===
{| width = "100%" {{Prettytable_B1}}
!width="20%"|Link
!width="10%"|Genre
!width="10%"|Lizenz
!width="5%"|GPL
!width="5%"|MPL
!width="5%"|OSS
!width="5%"|CSS
!width="5%"|Komm.
!width="35%"|Bemerkungen
|-
|[http://www.davegh.com/vg/home.htm davegh.com]
|Fantasy
|[http://www.davegh.com/vg/termsandconditions.htm Eigene]
|?
|?
|✔
|✔
|✘
|Die Lizenz vererbt sich in die Projekte hinein.
|-
|[http://www.cgtextures.com/ cgtextures.com]
|Allgemein
|[http://www.cgtextures.com/content.php?action=license Eigene]
|✘
|✘
|✘
|?
|?
|Die Lizenz will im wesentlichen verhindern das Texturen in anderen Textursammlungen auftauchen. So wie ich das verstehe ist es kein Problem die Texturen unter einer anderen Lizenz zu veröffentlichen als die eigentliche Software. Die Software kann also sehr wohl OpenSource sein. Im Zweifelsfalls einfach den Support anschreiben, der ist sehr nett.
|-
|[https://wiki.openstreetmap.org/wiki/Texture_Library OpenStreetMap Texture Library]
|Allgemein
|Public Domain
|✘
|✘
|✘
|✘
|✘
|Die Texturen dienen der Visualisierung der 3D-Gebäude im OpenStreetMap Projekt
|-
|url
|Futuristisch, Mittelalter, etc.
|CC-BY-SA, etc., gerne auch mit Direktlink auf die Lizenzseite, so vorhanden.
|✔/✘/?
|✔/✘/?
|✔/✘/?
|✔/✘/?
|✔/✘/?
|Alle Bilder sind von Käse
|}

=== Sonstige 2D-Grafiken ===

{| width = "100%" {{Prettytable_B1}}
!width="20%"|Link
!width="45%"|Beschreibung
!width="10%"|Lizenz
!width="5%"|GPL
!width="5%"|MPL
!width="5%"|OSS
!width="5%"|CSS
!width="5%"|Komm.
|-
|[http://www.famfamfam.com/lab/icons/silk/ famfamfam silk]
|Iconset, welches inzwischen relativ weit verbreitet ist. 700 sauber gezeichnete, erkennbare PNG-Icons in TrueColor. Man kann praktisch jede (Arbeits-)Anwendung mit diesem Set vollständig mit Icons versorgen.
|[http://creativecommons.org/licenses/by/2.5/ CC-BY 2.5], [http://creativecommons.org/licenses/by/3.0/ CC-BY 3.0]
|✔
|✔
|✔
|✔
|✔
|}

=== Texturerstellung ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://3d.diehlsworld.de/textures/index.htm 3d.diehlsworld.de]
|{{Deutsch}}
|Auf dieser Seite findet ihr kurze aber inhaltlich reiche Tutorials zu der Frage "Wie erstelle ich XXXXX-Texturen". Dabei reicht die Palette von Untergrundtexturen wie Gras, Sand , Fels und Wasser (und Kombinationen dieser) bis hin zu Blitzen und Partikeln. Als Programm wird hier Photoshop verwendet.
|-
|[http://www.gimps.de/gimp/textur-muster/ gimps.de]
|{{Deutsch}}
|Schritt für Schritt Anleitungen wie man mit Gimp verschiedene Texturen erstellt.
|-
|[http://cbt.k090999.de/gimp.php#texturen k090999.de]
|{{Deutsch}}
|Gimptutorials zum Erstellen verschiedene Texturen.
|}

== Modelle / 3D-Grafiken ==

=== Blender ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://blendpolis.de/f/viewtopic.php?t=5786 Blendpolis]
|{{Deutsch}}
| Ein Thread im Forum von [http://blendpolis.de Blendpolis] in dem '''sehr''' viele Tutorials aufgelistet sind
|-
|[http://blendpolis.de/f/article_cat.php?fldAuto=7 Blendpolis]
|{{Deutsch}}
| Eigentliche Tutorial Seite von [http://blendpolis.de Blendpolis] die Auswahl ist hier aber nicht so groß
|-
|[http://wikivid.com/index.php/Blender Blender at wikivid.com]
|{{Englisch}}
| Linksammlung von Blender Video Tutorials
|-
|[http://www.blender.org/education-help/tutorials/getting-started/ blender3d.org]
|{{Englisch}}
| Auch die Heimatseite von Blender bietet viele Tutorials unter anderm auch Video Tuorials
|-
|[http://www.Blenderunderground.com Blenderunderground]
|{{Englisch}}
| '''sehr gute''' Video-Tutorials
|}

== Sounds ==

===Musik===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.jamendo.com/ Jamendo.com]
|{{Englisch}}
|Viele Künstler stellen hier ihre Alben unter einer Creative Commons Lizenz online. Man kann dort die Künstler auch kontaktieren und fragen ob man ihre Musik nutzen kann. Taugt außerdem als Radio! ;)
|-
|[http://incompetech.com/m/c/royalty-free/ Incompetech.com]
|{{Englisch}}
|Viele sehr schön gemacht instrumentale Musik aus allen möglichen Genres. Sie ist frei verwenderbar, wenn man den Macher der Musik (Kevin MacLeod) in seinem Programm erwähnt. Aber das hat er auch verdient. Folgende Programme nutzen beispielsweise (auch) Musik von incompetech.com:
* OpenParty
|-
|}

===Soundeffekte===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.freesound.org/ freesound.org]
|{{Englisch}}
|Diverse Sounds unter [http://www.creativecommons.org/ CreativeCommons] Lizenzen.
|}

===Soundprogramme===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://audacity.sourceforge.net/?lang=de Sourceforgeseite von Audacity]
|{{Deutsch}}
|Ein einfaches, freies Programm um Sounddateien zu bearbeiten. Man kann es auch nutzen um Soundeffekte neu zu erstellen, indem man z.B. ein Geräusch mit dem Mikrofon aufnimmt und einige Effekt anwendet, um es passender und nicht mehr aufgenommen klingen zu lassen.
|-
|[http://lmms.sourceforge.net/ LMMS]
|{{Englisch}}
|LMMS (Linux MultiMedia Studio) ist ein OpenSource+Freeware Composer-Programm ähnlich zum bekannteren aber auch teuren CuBase(r). Trotz des Namens auch für Windows erhältlich.
|}

Link

2012-05-20T13:32:28Z

Lord horazont: /* Allgemein */ http://harablog.wordpress.com/2011/08/26/fast-pathfinding-via-symmetry-breaking/ hinzugefügt

Diese Linksammlung soll allgemeine Links zu unterschiedlichen Themen bieten, die mit der Multimediaentwicklung zu tun haben.
{{Hinweis|Vielleicht ist eine Zusammenführung mit [[Tool]] sinnvoll!}}
{{Hinweis|Vielleicht ist eine Aufteilung in Unterseiten sinnvoll (möglicherweise mit Kategorien)}}

= Entwicklung mit OpenGL =

== Hardwareinfos ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://web.archive.org/web/20090417044334/http://delphi3d.net/hardware/listreports.php OpenGL Hardware Registry - Hardwareübersicht]
|{{Englisch}}
|Eine Datenbank aller Grafikkarten die in der Harware Registry vorhanden sind. Die einzelnen Artikel enthalten Infos darüber, welche Extensions von der Grafikkarte unterstützt werden.
|-
|[http://web.archive.org/web/20090506094005/http://delphi3d.net/hardware/ OpenGL Hardware Registry - Extensionübersicht]
|{{Englisch}}
|Eine Datenbank aller Extensions die in der Harware Registry vorhanden sind. Die einzelnen Artikel enthalten Infos darüber, welche Grafikkarten die entsprechende Extension unterstützen.
|-
|}


== Tutorials ==

{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
||[[Tutorial|DGL Wiki - Tutorial]]
|{{Deutsch}}
|DelphiGL.com ist Betreiber dieses Wikis und stellt eine Vielzahl Tutorials mit Schwehrpunkt OpenGL zur Verfügung.
Neben Tutorials für Einsteiger und OpenGL Anfänger gibt es auch fortgeschrittene Themen wie Shader oder Partikelsysteme.Sprache der Wahl ist hier Delphi.
|-
|[http://www.joachimrohde.com/cms/xoops/modules/articles/index.php?cat_id=1 joachimrohde.com]
|{{Deutsch}}
|Auf dieser Seite findet ihr deutsche Übersetzungen der bekannten NeHe Tutorials. Sprache der Wahl ist hier C++.
|-
|[http://www.cg.tuwien.ac.at/studentwork/VRSem96/OpenGL/ Technische Universität Wien]
|{{Deutsch}}
|Diese Seite bietet einen allgemeinen Überblick über die primären Funktionen von OpenGL und richtet sich vor allem an Einsteiger.
|-
|[http://nehe.gamedev.net/ Nehe]
|{{Englisch}}
|Die berühmt berüchtigten NeHe Tutorials sind eine umfangreiche Sammlung an Tutorials zum Thema OpenGL. Von Anfängertutorials bis hin zu komplexen Effekten wird alles behandelt. Sprache der Wahl ist hier C++. (Eine Übersetzung der NeHe Tutorials findet ihr bei Joachim Rhode (siehe oben). )
|-
|[http://www.sulaco.co.za/tut.htm sulaco.co.za]
|{{Englisch}}
| OpenGL Beispiele in Delphi
|}

== OpenGL Funktionen ==

=== GL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GL|DGL Wiki - Kategorie GL]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten OpenGL Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL.tar.gz OpenGL.org - Original Spezifkationen]
|{{Englisch}}
|Die Originalspezifikationen der OpenGL 1.0 und OpenGL 1.1 Befehle. (Diese HTML-Dokumente sind nicht Copy&Paste freundlich, da sie vermutlich automatisch aus vorhandenen Dateien (Postscript) erzeugt wurden.)
|-
|[http://developer.3dlabs.com/documents/glmanpage_index.htm 3dLabs]
|{{Englisch}}
|Die Originalspezifikationen der OpenGL 1.0 und OpenGL 1.1 Befehle.
|-
|[http://web.archive.org/web/20040616082839/http://www.mevis.de/~uwe/opengl/opengl.html mevis.de]
|{{Englisch}}
|Sammlung von Englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|[http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/glfunc01_4f03.asp MSDN von Microsoft]
|{{Englisch}}
|OpenGL Dokumentation in der MSDN. Die Erklärung der MSDN sind meist keine reinen Kopien der Originalspezifikationen, sondern enthalten hin und wieder auch zusätzliche Informationen, oder formulieren Texte auf verständlichere Art und Weise.
|-
|}

=== GLU ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GLU|DGL Wiki - Kategorie GLU]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten GLU Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/glu/ OpenGL.org - Original Spezifkationen]
|{{Englisch}}
|Originalspezifikationen für die GLU Befehle. (Diese HTML-Dokumente sind nicht Copy&Paste freundlich, da sie vermutlich automatisch aus vorhandenen Dateien (Postscript) erzeugt wurden.)
|-
|[http://web.archive.org/web/20040616082839/http://www.mevis.de/~uwe/opengl/opengl.html mevis.de mevis.de]
|{{Englisch}}
|Sammlung von englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|[http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/glufnc01_0e43.asp MSDN von Microsoft]
|{{Englisch}}
|GLU Dokumentation in der MSDN. Die Erklärung der MSDN sind meist keine reinen Kopien der Originalspezifikationen, sondern enthalten hin und wieder auch zusätzliche Informationen, oder formulieren Texte auf verständlichere Art und Weise.
|-
|}

=== GLX ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GLX|DGL Wiki - Kategorie GLX]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten GLX Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/glx/ OpenGL.org - Original Spezifkationen]
|{{Englisch}}
|Orgninalspezifikationen der GLX Befehle bei OpenGL.org.
|-
|[http://web.archive.org/web/20040616082839/http://www.mevis.de/~uwe/opengl/opengl.html mevis.de mevis.de]
|{{Englisch}}
|Sammlung von Englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|}

=== WGL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:WGL|DGL Wiki - Kategorie WGL]]
|{{Deutsch}}
|Wiki-Kategorie die alle übersetzten WGL Befehle enthält.
|-
|[http://web.archive.org/web/20071218151417/http://developer.3dlabs.com/documents/wglmanpage_index.htm 3dLabs]
|{{Englisch}}
|Sammlung einiger WGL Befehlsspezifikationen.
|-
|}

=== GLUT ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://freeglut.sourceforge.net/docs/api.php The freeglut Projekt]
|{{Englisch}}
|Englischsprachige Dokumentation zum OpenGL Utility Toolkit kurz GLUT.
|-
|}

=== SDL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:SDL|DGL Wiki - Kategorie SDL]]
|{{Deutsch}}
|Übersicht aller auf die SDL bezogenen Artikel hier im Wiki. Darunter befinden sich eine Vielzahl von Übersetzungen der SDL Befehlspezifikationen. Diese können auch in der [[SDL-Funktionsübersicht]] gefunden werden.
|-
|[http://www.libsdl.org/cgi/docwiki.cgi/SDL_20API libsdl.org]
|{{Englisch}}
|Das Dokumentationswiki von libSDL.org enthält die komplette Dokumenation zur SDL in englischer Sprache.
|-
|-
|[http://www.freepascal-meets-sdl.net/ freepascal meets sdl]
|{{Englisch}}
| Eine Webseite die speziell Informationen über die Programmierung von SDL unter Freepascal zur Verfügung stellt.
|-
|}

== FAQs ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[FAQ| DGL Wiki - FAQ]]
|{{Deutsch}}
|Ein FAQ (Frequently Asked Questions = Häufig gestellte Fragen) zu DelphiGL.com und dem DGL Wiki.
|-
|[http://www.3dsource.de/faq/index.htm 3dsource.de]
|{{Deutsch}}
|Ein FAQ zu Fragen rund um OpenGL.
|-
|}

== Effekte und Techniken mit OpenGL ==

===Glow===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamasutra.com/view/feature/2107/realtime_glow.php Gamasutra]
|{{Englisch}}
|Beschreibt, wie man mit Hilfe von Shader(hier DirectX Shader) den Gloweffekt in Realtime umsetzt. Dabei wird erst die Technik dahinter erklärt, und dann wie man sie Schritt für Schritt umsetzt.
|-
|[http://web.archive.org/web/20071118043007/http://collective.valve-erc.com/index.php?go=tron1 valve-erc.com]
|{{Englisch}}
|Schritt für Schritt Anleitung, wie man mit Hilfe von Cg in OpenGL den Glow Effekt realisieren kann
|-
|}

===HDR===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://web.archive.org/web/20090601052809/http://www.gamedev.net/columns/hardcore/hdrrendering/ gamedev.net]
|{{Englisch}}
|Hier wird sehr kurz eingeleitet, was HDR Rendering überhaupt ist, dann wird der Aufbau des *.hdr Formats erläutert, und dann geht es schon von 0 auf 100 zum Programmieren. Erklärungen gibt es kaum, dafür werden fertige Shader(für DirectX) geboten.
|-
|[http://web.archive.org/web/20090601202039/http://www.gamedev.net/reference/articles/article2208.asp gamedev.net]
|{{Englisch}}
|Beschreibt auch nur etwas kurz das HDR Verfahren, jedoch mit mehr mathematischen Hintergrund in Sachen Tonemapping. Beispielcode für Tonemapping in C++ liegt bei.
|-
|}

===BSP Bäume===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://web.archive.org/web/20081201115631/http://www.3dtechdev.com/tutorials/leafbsp/3dbsptrees.html 3dtechdev.com]
|{{Englisch}}
|Das beste Dokument überhaupt, für allem die selber BSP Bäume compilieren möchte. Ist belegt mit sehr viel Grafik. Erst beginnt er das Prinzip allgemein zum umschreiben, dann wird alles genau erläutert, und mit verständlichen Pseudocode untermalt.
|-
|[http://web.archive.org/web/20081019041535/http://www.3dtechdev.com/tutorials/illegalgeometry/illegalgeometrytut.html 3dtechdev.com]
|{{Englisch}}
|Nicht ganz so gut geworden, wie sein erstes Tutorial, aber erklärt auch sehr gut, wie man illegale Geometrie aufspürt und beseitigt. Wieder mit Grafiken und Pseudocodes verständlich belegt. Hiermit kann man seinem Map-Compiler den letzten Schliff verleien.
|-
|[http://www.gamedev.net/reference/articles/article981.asp Gamedev]
|{{Englisch}}
|Von Michael Abrash, dürfte der ''Erfinder'' von Quake sein. Naja, meine Englischkenntnisse reichen hier nicht ganz aus, um den Text zu verstehen. Ist etwas umständlich geschrieben. Dafür mit Grafiken unterlegt.
|-
|[http://www.zfx-online.de/Tutorials.php?ID=11 Part 1 - Allgemein]
|{{Deutsch}}
|Einzigste deutsche Referenz zu BSP Bäumen, dafür Daumen hoch. Ist aber nicht das Wahre: schlechter C Code, und ich hatte auch nicht den Einduck, das er die Theorie zu diesem Thema bis in die Tiefe verstanden hat(oder er wollte es nicht zu akademisch Erklären oO). Aber ein guter Einstieg in dieses Thema.
|-
|[http://www.zfx-online.de/Tutorials.php?ID=13 Part 2 - Kollision und PVS]
|{{Deutsch}}
|-
|[http://web.archive.org/web/20060516103821/http://www.cs.uwec.edu/~stevende/cs455/programs/GameTutorials%20-%20Quake%203%20BSP%20Format.htm Quake3 *.bsp Format]
|{{Englisch}}
|Die beste Dokumentation für das BSP Format, die ich gefunden habe, besser als den Quake3 Sourcecode zu durchforsten. Leider etwas magere Eklährung zu wichtigen Themen wie Patches(Curved Surfaces). Ich pers. hatte jetzt 1 1/2 Wochen gebraucht, um das *.bsp Format vollständig zu verstehen. Ist aber anscheinend die beste Format Dokumentation im Netz.
|-
|[http://www.flipcode.com/articles/article_q2bsp.shtml Quake2 *.bsp Format]
|{{Englisch}}
|Kann auch nur soviel sagen, wie beim Link zuvor. Es fehlen hier auch zum Teil Informationen. Man muss halt viel ausprobieren, und sich den Quake 2 Source zu Herzen nehmen, damit man es versteht.
|-
|}

===Himmel & Wolken===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamedev.net/community/forums/topic.asp?topic_id=86024 Gamedev]
|{{Englisch}}
|Guter Thread mit vielen Anregungen und Links.
|-
|[http://www.gamedev.net/community/forums/topic.asp?topic_id=135654 Gamedev]
|{{Englisch}}
|Hier wird die Diskussion zum obigen Link weitergeführt.
|-
|[http://freespace.virgin.net/hugo.elias/models/m_clouds.htm Plasma]
|{{Englisch}}
|Eine nette Idee um Plasma in Echtzeit zu generieren, und zu verändern. Leider nichts zum Shading.
|-
|[http://nis-lab.is.s.u-tokyo.ac.jp/~nis/cdrom/sig00_cloud.pdf 3D Wolken]
|{{Englisch}}
|Paper über generieren und rendern von 3 dimensionalen Wolken inklusive Schatten und Lichtstrahlen. Ich hab nur den Lichtstahlen-Algorithmus ausprobiert. Saulangsam aber sehr einfach zu implementieren. Einen Blick ist es auf jeden Fall wert.
|-
|[http://web.archive.org/web/20031011052035/http://www.geocities.com/ngdash/whitepapers/skydomecolor.html Skydome]
|{{Englisch}}
|Wenn man mal schnell gute Farben für seinen Skydome braucht...
|}

===Terrain===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.flipcode.com/articles/article_geomipmaps.shtml FlipCode]
|{{Englisch}}
|Artikel zu Geomipmaping. Zummindest hab ich es hier zum ersten mal gesehen. Und es funzt ganz gut.
|-
|[http://www.vterrain.org Virtual Terrain Project]
|{{Englisch}}
|Eine Seite mit Links und Artikeln zu allem, was etwas mit Terrainrendering zu tun hat.
|-
|}

===Sonstiges===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[Materialsammlung]]
|{{Deutsch}}
|Sammlung von gängigen Parametern für [[glMaterial]] hier im Wiki.
|-
|[http://freespace.virgin.net/hugo.elias/radiosity/radiosity.htm Radiosity]
|{{Englisch}}
|Erklärt sehr schön die Funktionsweise von Radiosity, liefert Beispielcodes und ist recht gut illustriert.
|-
|[http://web.archive.org/web/20050825110920/http://legion.gibbering.net/projectx/paper/shadow%20mapping/ Shadowmapping]
|{{Englisch}}
|Beschreibt das Trapezoidal Shadow Mapping - Verfahren für gerichte Lichter.
|-
|[http://www.flipcode.com/articles/article_generatingnames.shtml Namensgenerator]
|{{Englisch}}
|Per Zufallsgenrator Namen erzeugen, und nie wieder kreativ werden müssen.
|-
|[http://www.paulsprojects.net/tutorials/simplebump/simplebump.html Bumpmapping]
|{{Englisch}}
|Bumpmapping auf Lowend-Grakas. Damals war Bumpmapping noch was ganz tolles...
|-
|[http://www.paulsprojects.net/opengl/dpreflect/dpreflect.html Dot Product Reflect]
|{{Englisch}}
|zwar nur ne Demo, aber wenn man schon immer mal mit EMBM das Wasser aus Morrowind nachproggen wollte...
|-
|}

== Beispiele/Demos mit Quelltext ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.delphigl.de DelphiGL.de]
|{{Deutsch}}
| Hier finden sich besonders eindrucksvolle Newton Physik Demos. Meißtens sogar mit Quelltext.
|-
|[http://www.shadow3d.de.vu/ Shadow 3D]
|{{Deutsch}}
| Hier finden sich zwei Demos wie man Quake 3 Modelle lädt und eine glSlang Demo
|-
|[[Shadersammlung]] im DGL Wiki
|{{Deutsch}}
| Hier findet man freie Shadersourcen.
|-
|[http://www.humus.name Humus]
|{{Englisch}}
| Diverse eindrucksvolle Demos zu verschiedenen Techniken, häufig mit Quelltext in C (teilweise OpenGL / DirectX)
|}

== weitere Links ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www-user.tu-chemnitz.de/~pester/Lehre/CompGeo.pdf CompGeo.pdf]
|{{Deutsch}}
| Script "Einführung in die Computergeometrie" von Dr. Pester (TU-Chemnitz). Ideales Nachschlagewerk für die Mathematik die einem bei der Grafikprogrammierung so begegnet.
|-
|[http://www.robsite.de/ robsite.de]
|{{Deutsch}}
| Auf dieser riesigen Seite finden sich auch viele weitere Links über verschiedene Themen der 3D Programmierung.
|-
|[http://www.3dlinks.com/links.cfm?categoryid=3&subcategoryid=21 3dlinks.com]
|{{Englisch}}
| Diese Seite hat es sich zur Hauptaufgabe gemacht Links auf Seiten mit dem Thema 3D zu sammeln.
|-
|[http://www.two-kings.de/links.html two-kings.de]
|{{Englisch}}
| Sammlung diverser interessanter Links, vorallem auf Themen im gamedev-Forum verweisend.
|-
|[http://www.delgine.com Delgine.com]
|{{Englisch}}
| Heimat des freien 3D Modellers "DeleD", welcher in Delphi programmiert ist. Ihr findet dort auch Modellpackete, Texturpackete, Plugins und Hilfe bei der Programmierung von Delphi und OpenGL.
|}

= Spieleentwicklung =

==Allgemein==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.spieleprogrammierung.net/ Spieleprogrammierung - OpenGL - GLSL - OpenAL - KI - Animation - Spielephysik]
|{{Deutsch}}
|Auf dieser Seite findet Ihr Artikel, Tutorials und Programmbeispiele rund um das Thema Spieleprogrammierung. Programmiersprache ist hier C/C++.
|-
|[http://graphics-and-physics-framework.spieleprogrammierung.net/ OpenGL Graphics And Physics Framework]
|{{Deutsch}}
|Auf dieser Seite findet Ihr ein frei verfügbares OpenGL basiertes Grafik und Physik Framework (LGPL-Lizenz) samt zugehöriger Probammbeispiele. Programmiersprache ist hier C/C++.
|-
|[http://audio-framework.spieleprogrammierung.net/ OpenAL Audio Framework]
|{{Deutsch}}
|Auf dieser Seite findet Ihr ein frei verfügbares OpenAL Audio Framework (LGPL-Lizenz) samt zugehöriger Probammbeispiele. Unterstützt werden 3D Sounds, EFX (EAX Alternative) Reverb Effekte sowie Audio Streaming (Music and Voices). Programmiersprache ist hier C/C++.
|-
|[http://spieleentwicklung-im-web.spieleprogrammierung.net/ Spieleentwicklung im Web]
|{{Deutsch}}
|Auf dieser Seite findet Ihr Links (E-Books, Präsentationen, wissenschaftliche Arbeiten und Tutorials) zu verschiedenen Themengebieten der Spieleentwicklung.
|-
|[http://harablog.wordpress.com/2011/08/26/fast-pathfinding-via-symmetry-breaking/]
|{{Englisch}}
|Optimierungen für A* Pfadsuche durch Ausnutzung von Symmetrien.
|-
|}

==Kopierschutz==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://inner-smile.com/nocrack.phtml Inner-Smile.com]
|{{Englisch}}
| Seite mit Gedanken zum Thema "Wie schütze ich meine Programme vor Crackern". Falls die Seite nicht erreichbar ist hat Google noch ne [http://www.google.com/search?q=cache:hpqPT5G4WB0J:www.inner-smile.com/nocrack.phtml+http://inner-smile.com/nocrack.phtml&hl=de&gl=de&ct=clnk&cd=1 Version im Archiv].
|-
|}

== Künstliche Intelligenz ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://web.archive.org/web/20080319034335/http://www.kbs.uni-hannover.de/Lehre/KI2/Presentationen/presentation9798/esprit/spieltheorie/spieltheorie.html Uni-Hannover - Spieltheorie]
|{{Deutsch}}
|Artikel über die Grundlagen von KI in Spielen.
|-
|[http://web.archive.org/web/20080927010337/http://www.robsite.de/tutorials.php?tut=ki Robsite KI-Tutorials]
|{{Deutsch}}
| Sammlung von Texten zum Thema KI in Spielen. Beispiele sind meist in C++.
|-
|[http://ai-depot.com/ AI-Depot.com]
|{{Englisch}}
| Seite die sich ausschließlich mit KI in Spielen beschäftigt.
|-
|[http://www.ai-junkie.com/links.html AI-Junkie.com]
|{{Englisch}}
|Linkseite mit vielen KI relevanten Links. Die Seite AI-Junie selbst behandelt auch viele Themen rund um KI.
|-
|[http://www.aiwisdom.com/ AIWisdom.com]
|{{Englisch}}
|Seite die sich mit KIs in Spielen beschäftigt und sich zum Ziel gesetzt hat, alle Artikel zum Thema zu finden und zu Katalogisieren. Es gibt hier auch Artikel über die KIs bestehender Spiele.
|-
|[http://www.aiguru.com/ AIGuru.com]
|{{Englisch}}
|Newsseite zum Thema KI, Künstliches Leben, Hiernforschung, Robotik, Nanotechnologie - Halt alles was Spass macht.
|-
|[http://www.generation5.org/ Generation5.org]
|{{Englisch}}
|Seite über KI, Robotik, etc. . Leider scheint die Seite Probleme zu haben regelmäßig aktualisiert zu werden. Aber zumindest sollte man einige Artikel finden. Die werden ja nicht schlecht.
|-
|[http://web.archive.org/web/20080702005527/http://www.gameai.com/ www.gameai.com]
|{{Englisch}}
|''Wurde Januar 2010 als down gemeldet. Weiss irgendwer etwas genaueres?'' Seite zum Thema KI in Spielen. Soll wohl einen gewissen Stellenwert in der AI-Szene haben.
|-
|[http://www-i1.informatik.rwth-aachen.de/~algorithmus/algo19.php Algorithmus der Woche - Informatikjahr 2006]
|{{Deutsch}}
|Vielleicht schon etwas älter aber doch eine gute Anleitung um eine einfache Schach-KI zu erstellen.
|}

= Ressourcen =
In dieser Gruppe finden sich Links um die Ressourcen für Eure Projekte zu erstellen.

== Texturen / 2D-Grafiken ==

'''Legende:'''
:'''Kostenpflichtige Seiten''' sind mit einem * zu '''kennzeichnen'''
:GPL: Kompatibel mit der GPL
:MPL: Kompatibel mit der MPL
:OSS: Verwendung in OpenSource Software nicht verboten
:CSS: Verwendung in ClosedSource Software nicht verboten
:Komm: Verwendung in kommerzieller Software nicht verboten

=== Texturen ===
{| width = "100%" {{Prettytable_B1}}
!width="20%"|Link
!width="10%"|Genre
!width="10%"|Lizenz
!width="5%"|GPL
!width="5%"|MPL
!width="5%"|OSS
!width="5%"|CSS
!width="5%"|Komm.
!width="35%"|Bemerkungen
|-
|[http://www.davegh.com/vg/home.htm davegh.com]
|Fantasy
|[http://www.davegh.com/vg/termsandconditions.htm Eigene]
|?
|?
|✔
|✔
|✘
|Die Lizenz vererbt sich in die Projekte hinein.
|-
|[http://www.cgtextures.com/ cgtextures.com]
|Allgemein
|[http://www.cgtextures.com/content.php?action=license Eigene]
|✘
|✘
|✘
|?
|?
|Die Lizenz will im wesentlichen verhindern das Texturen in anderen Textursammlungen auftauchen. So wie ich das verstehe ist es kein Problem die Texturen unter einer anderen Lizenz zu veröffentlichen als die eigentliche Software. Die Software kann also sehr wohl OpenSource sein. Im Zweifelsfalls einfach den Support anschreiben, der ist sehr nett.
|-
|[https://wiki.openstreetmap.org/wiki/Texture_Library OpenStreetMap Texture Library]
|Allgemein
|Public Domain
|✘
|✘
|✘
|✘
|✘
|Die Texturen dienen der Visualisierung der 3D-Gebäude im OpenStreetMap Projekt
|-
|url
|Futuristisch, Mittelalter, etc.
|CC-BY-SA, etc., gerne auch mit Direktlink auf die Lizenzseite, so vorhanden.
|✔/✘/?
|✔/✘/?
|✔/✘/?
|✔/✘/?
|✔/✘/?
|Alle Bilder sind von Käse
|}

=== Sonstige 2D-Grafiken ===

{| width = "100%" {{Prettytable_B1}}
!width="20%"|Link
!width="45%"|Beschreibung
!width="10%"|Lizenz
!width="5%"|GPL
!width="5%"|MPL
!width="5%"|OSS
!width="5%"|CSS
!width="5%"|Komm.
|-
|[http://www.famfamfam.com/lab/icons/silk/ famfamfam silk]
|Iconset, welches inzwischen relativ weit verbreitet ist. 700 sauber gezeichnete, erkennbare PNG-Icons in TrueColor. Man kann praktisch jede (Arbeits-)Anwendung mit diesem Set vollständig mit Icons versorgen.
|[http://creativecommons.org/licenses/by/2.5/ CC-BY 2.5], [http://creativecommons.org/licenses/by/3.0/ CC-BY 3.0]
|✔
|✔
|✔
|✔
|✔
|}

=== Texturerstellung ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://3d.diehlsworld.de/textures/index.htm 3d.diehlsworld.de]
|{{Deutsch}}
|Auf dieser Seite findet ihr kurze aber inhaltlich reiche Tutorials zu der Frage "Wie erstelle ich XXXXX-Texturen". Dabei reicht die Palette von Untergrundtexturen wie Gras, Sand , Fels und Wasser (und Kombinationen dieser) bis hin zu Blitzen und Partikeln. Als Programm wird hier Photoshop verwendet.
|-
|[http://www.gimps.de/gimp/textur-muster/ gimps.de]
|{{Deutsch}}
|Schritt für Schritt Anleitungen wie man mit Gimp verschiedene Texturen erstellt.
|-
|[http://cbt.k090999.de/gimp.php#texturen k090999.de]
|{{Deutsch}}
|Gimptutorials zum Erstellen verschiedene Texturen.
|}

== Modelle / 3D-Grafiken ==

=== Blender ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://blendpolis.de/f/viewtopic.php?t=5786 Blendpolis]
|{{Deutsch}}
| Ein Thread im Forum von [http://blendpolis.de Blendpolis] in dem '''sehr''' viele Tutorials aufgelistet sind
|-
|[http://blendpolis.de/f/article_cat.php?fldAuto=7 Blendpolis]
|{{Deutsch}}
| Eigentliche Tutorial Seite von [http://blendpolis.de Blendpolis] die Auswahl ist hier aber nicht so groß
|-
|[http://wikivid.com/index.php/Blender Blender at wikivid.com]
|{{Englisch}}
| Linksammlung von Blender Video Tutorials
|-
|[http://www.blender.org/education-help/tutorials/getting-started/ blender3d.org]
|{{Englisch}}
| Auch die Heimatseite von Blender bietet viele Tutorials unter anderm auch Video Tuorials
|-
|[http://www.Blenderunderground.com Blenderunderground]
|{{Englisch}}
| '''sehr gute''' Video-Tutorials
|}

== Sounds ==

===Musik===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.jamendo.com/ Jamendo.com]
|{{Englisch}}
|Viele Künstler stellen hier ihre Alben unter einer Creative Commons Lizenz online. Man kann dort die Künstler auch kontaktieren und fragen ob man ihre Musik nutzen kann. Taugt außerdem als Radio! ;)
|-
|[http://incompetech.com/m/c/royalty-free/ Incompetech.com]
|{{Englisch}}
|Viele sehr schön gemacht instrumentale Musik aus allen möglichen Genres. Sie ist frei verwenderbar, wenn man den Macher der Musik (Kevin MacLeod) in seinem Programm erwähnt. Aber das hat er auch verdient. Folgende Programme nutzen beispielsweise (auch) Musik von incompetech.com:
* OpenParty
|-
|}

===Soundeffekte===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.freesound.org/ freesound.org]
|{{Englisch}}
|Diverse Sounds unter [http://www.creativecommons.org/ CreativeCommons] Lizenzen.
|}

===Soundprogramme===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://audacity.sourceforge.net/?lang=de Sourceforgeseite von Audacity]
|{{Deutsch}}
|Ein einfaches, freies Programm um Sounddateien zu bearbeiten. Man kann es auch nutzen um Soundeffekte neu zu erstellen, indem man z.B. ein Geräusch mit dem Mikrofon aufnimmt und einige Effekt anwendet, um es passender und nicht mehr aufgenommen klingen zu lassen.
|-
|[http://lmms.sourceforge.net/ LMMS]
|{{Englisch}}
|LMMS (Linux MultiMedia Studio) ist ein OpenSource+Freeware Composer-Programm ähnlich zum bekannteren aber auch teuren CuBase(r). Trotz des Namens auch für Windows erhältlich.
|}

Tutorial glsl

2012-03-15T17:06:10Z

Lord horazont: /* Texturenzugriffe */ Hinweis auf Unterschied zwischen Texturnamen und Texturunit eingefügt.

=Einleitung=
Hallo und willkommen bei meiner "Einführung" in GLSL (kurz für "Open'''GL''' '''S'''hading '''L'''anguage"), der offiziellen Hochlevel-Shadersprache von OpenGL. In diesem umfangreichen Dokument werde ich versuchen, sowohl auf die Nutzung (sprich das Laden und Anhängen von Shadern im Quellcode), als auch auf die Programmierung von Shadern selbst einzugehen, inklusive aller Sprachelemente der OpenGL Shadersprache. Es wird also auch recht viele Informationen zu der C-ähnlichen Programmstruktur und den von GLSL angebotenen Variablen und Attributen gehen. Am Ende dieser Einführung sollten alle die, die sich für das Thema interessieren, in der Lage sein, zumindest einfach Shader zu schreiben und auch in ihren Programmen zu nutzen. Ausserdem soll dieses Dokument gleichzeitig als ein deutsches "Pendant" zu den von Khronoes veröffentlichten Shaderspezifikationen, und damit als alltägliches Nachschlagewerk, dienen.

==Vorkenntnisse==
Wie auch schon mein ARB_VP-Tutorial richtet sich auch diese Einführung aufgrund ihrer Thematik eher an die fortgeschritteneren GL-Programmierer und neben sehr guten GL-Kenntnissen sollten sich alle, die sich daran versuchen wollen, mit den technischen Hintergründen der GL, wie z.B. dem Aufbau der Renderpipeline auskennen. Weiterhin sind C-Kenntnisse absolut erforderlich, da die Shader ja in einer an ANSI-C angelehnten Syntax geschrieben werden. Auch Begriffsdefinitionen zu Vertex oder Fragment werden zum Verständis dieser Einführung benötigt. Wer also noch am Anfang seiner GL-Karriere steht, dem wird dieses Dokument nicht viel nützen. Ganz nebenbei solltet ihr auch noch eine gehörige Portion Zeit (am besten nen kompletten Nachmittag) mitbringen, denn die folgende Kost ist nicht nur umfangreich, sondern auch manchmal recht schwer verdaulich.

=Was ist GLSL?=
Wie Eingangs kurz angesprochen handelt es sich bei GLSL um eine Shadersprache, also um eine Hochsprache, in der man die programmierbaren Teile aktueller Grafikbeschleuniger nach eigenem Belieben programmieren kann. Sie stellt quasi den Nachfolger zu den in Assembler geschriebenen Vertex- und Fragmentprogrammen ([[GL_ARB_vertex_program]]/[[GL_ARB_fragment_program]]) dar und basiert auf ANSI C, erweitert um Vektor- und Matrixtypen sowie einige C++-Mechanismen.

Die in GLSL geschriebenen Programme nennen sich, angepasst an die Terminologie von RenderMan und DirectX, [[Shader]] (im Gegensatz zu "Programme" bei ARB_VP/FP) und werden entweder auf Eckpunkte (VertexShader), Fragmente (FragmentShader) angewendet, oder (neuerdings, ab Shadermodell 4.0) auch genutzt um Geometrie zu erstellen (Geometryshader). Andere Teile der Renderpipeline (z.B. die Rasterisierung) können momentan noch nicht durch Shader beeinflusst werden, was allerdings in Zukunft noch kommen kann.

==Voraussetzungen==

GLSL wurde 2005 mit OpenGL 1.5 eingeführt. Während es in Sachen Treiber- und Hardwareunterstützung anfänglich noch dürftig aussah, wird man inzwischen keine Grafikkarte mehr kaufen können die nicht zumindest Vertex- und Fragmentshader beherscht. Geometrieshader hingegen sind relativ neu und wurden erst mit Shadermodell 4.0 eingeführt, hier ist es also unter Umständen noch möglich dass selbst aktuelle Treiber/Karten keine Geometrieshader beherrschen.

Natürlich benötigt man auch einen passenden OpenGL-Header der die für GLSL nötigen Funktionen exportiert. Ich verweise dazu auf unseren eigenen OpenGL-Header [[DGLOpenGL.pas]], der peermanent auf dem aktuellsten Stand gehalten wird und auch Support für Geometrieshader mitbringt.

==Extensions==

Die GL-Shadersprache "besteht" in ihrer aktuellen Version aus folgenden Extensions, fürs Verständnis wäre es nicht schlecht, wenn ihr euch zumindest die Einleitungen dazu durchlest :
* [[GL_ARB_shader_objects]] ([http://oss.sgi.com/projects/ogl-sample/registry/ARB/shader_objects.txt Originalspezifikation])
: Definiert die API-Aufrufe, die zum Erstellen, Kompilieren, Linken, Anhängen und Aktivieren von Shader- und Programmobjekten nötig sind.
* [[GL_ARB_vertex_shader]] ([http://oss.sgi.com/projects/ogl-sample/registry/ARB/vertex_shader.txt Originalspezifikation])
: Fügt der OpenGL Programmierbarkeit auf Vertexebene hinzu.
* [[GL_ARB_fragment_shader]] ([http://oss.sgi.com/projects/ogl-sample/registry/ARB/fragment_shader.txt Originalspezifikation])
: Fügt der OpenGL Programmierbarkeit auf Fragmentebene hinzu.
* [[GL_ARB_shading_language_100]] ([http://oss.sgi.com/projects/ogl-sample/registry/ARB/shading_language_100.txt Originalspezifikation])
: Gibt die unterstützte Version von glSlang an, momentan 1.00.

'''Hinweis''' : Seit OpenGL 2.0 ist GLSL Teil des Kerns. Wenn die Karte also OpenGL 2.0 unterstützt, dann unterstützt sie auch (zumindest in Software) Vertex- und Fragmentshader.

==Sprachversionen==

Neben der OpenGL-Version und dem vorhandenen Shadermodell (das eher an DirectX ausgerichtet ist), bietet auch GLSL verschiedene Versionen, die entsprechend erweiterte Funktionalität bieten.

Auslesen kann man die verfürgbare GLSL-Version wie folgt:

glGetString(GL_SHADING_LANGUAGE_VERSION)

Erst ab Version 1.4. kann man davon ausgehen dass GLSL alle Features des Shadermodells 4.0 liefert, ab 1.3 grob gesagt Shadermodell 3.0 (bei GLSL lässt sich das leider nicht so leicht unterteilen).

Ausserdem kann man seinem Shader eine Versionsnummer verpassen. Sollte der Shadercompiler (also Treiber bzw. Hardware) diese Version nicht unterstützen, gibt dieser eine Fehlermeldung heraus:

#version 1.50

''(Hinweis: Muss am Anfang des Shaders stehen)''

==Objekte==

Im Zuge der Vereinheitlichung der GL wird immer häufiger in Objekte gekapselt, deren API dann auch aneinander angelehnt ist. Ziel ist, dabei die Programmierung der GL uniform zu machen, so dass z.B. zwischen dem Erstellen und Verwalten eines Vertex-Buffer-Objektes oder eines Shader-Objektes kaum ein Unterschied besteht (demnächst kommen dann auch Pixel-Buffer-Objekte dazu). Mit glSlang wurden dann im Zuge dieser Aktion zwei neue Objekte eingeführt, deren Definition ihr euch unbedingt einprägen solltet:

* '''Programmobjekt'''
:Ein Objekt, an das die Shader später angebunden werden. Bietet Funktionalität zum Linken der Shader und prüft dabei die Kompatibilität zwischen Vertex- und Fragmentshader.

* '''Shaderobjekt'''
:Dieses Objekt verwaltet den Quellcodestring eines Shaders und ist entweder vom Typ '''GL_VERTEX_SHADER''', '''GL_FRAGMENT_SHADER_ARB''' oder '''GL_GEOMETRY_SHADER'''.

==Ressourcen==

Die Shadersprache ist keinesfalls final und es wurden bereits diverse Ausdrücke für zukünftige Verwendung reserviert, denn ein Ziel bei ihrer Entwicklung war es, sie so zukunftsorientiert zu gestalten, dass auch Grafikkarten der nächsten und übernächsten Generation voll ausgenutzt werden können. Damit einher geht die Tatsache, dass sich die Spezifikationen in Zukunft ändern/erweitern werden, weshalb man da immer einen Blick hineinwerfen sollte. Die Anlaufstelle dafür ist die [http://www.opengl.org/documentation/specs/ Spezifikationenliste auf OpenGL.org].

=GLSL im Programm=
Bevor wir uns mit der Syntax von glSlang beschäftigen, zeige ich euch erstmal, wie ihr Shader in euer Programm einbindet und nutzt. Warum das zuerst? Ganz einfach deshalb, weil ihr dann das, was ihr im glSlang-Syntaxteil lernt, direkt in eurer Testanwendung verwenden könnt. Hoffe diese Entscheidung klingt logisch und findet Anklang.

Zuerst benötigen wir natürlich unsere Objekte. Zum einen ein ''Programmobjekt'', an das unsere Shader gebunden werden, und zwei ''Shaderobjekte'', die den Quellcode unseres Vertex bzw. Fragment Shaders aufnehmen. Dazu wurde eigens der neue "Datentyp" {{INLINE_CODE|glHandle}} eingeführt, der ein Objekthandle repräsentiert. Wir deklarieren also wie folgt :

ProgramObject : GLhandle;
VertexShaderObject : GLhandle;
FragmentShaderObject : GLhandle;

Nach dieser Deklaration können wir dann damit beginnen unsere Objekte zu erstellen. Den Anfang macht das Programmobjekt :

ProgramObject := glCreateProgram;

Die Funktion [[glCreateProgram]] erstellt uns oben ein leeres Programmobjekt und gibt ein gültiges Handle darauf zurück.

Weiter gehts mit der Erstellung unseres Vertex bzw. Fragment Shaders :

VertexShaderObject := glCreateShader(GL_VERTEX_SHADER);
FragmentShaderObject := glCreateShader(GL_FRAGMENT_SHADER);

[[glCreateShader]] dient zur Generierung eines leeren Shaderobjektes. Momentan unterstützt diese Funktion VertexShader und FragmentShader.

Nachdem wir nun also zwei gültige Shaderobjekte haben, wollen wir diese auch mit entsprechendem Quellcode versorgen :

glShaderSource(VertexShaderObject, 1, @ShaderText, @ShaderLength);
glShaderSource(FragmentShaderObject, 1, @ShaderText, @ShaderLength);

Via [[glShaderSource]] setzen wir den Quellcode eines Shaderobjektes ''komplett'' neu. Zum Laden des Quellcodes bietet sich unter Delphi übrigens eine TStringList geradezu an. Es sollte beachtet werden, dass der Quellcode zu diesem Zeitpunkt ''nicht geparst'' wird, also keine Fehleruntersuchung stattfindet.

Der Quellcode wurde jetzt also an unsere Shaderobjekte gebunden und sollte dann natürlich auch noch kompiliert werden :

glCompileShader(VertexShaderObject);
glCompileShader(FragmentShaderObject);

Der glSlang-Compiler des Treibers wird bei einem Aufruf von [[glCompileShader]] versuchen, unsere Shader zu kompilieren. Sofern diese keine Fehler aufweisen, sollte dies auch erfolgreich sein. Wenn nicht, dann spuckt uns der Shadercompiler (je nach Treiber) recht detaillierte Infos aus. Wie man an diese Infos kommt könnt ihr gleich nachlesen.

Wenn unsere Shader dann kompiliert werden konnten, ist es Zeit, diese an unser anfangs erstelltes Programmobjekt anzuhängen :

glAttachShader(ProgramObject, VertexShaderObject);
glAttachShader(ProgramObject, FragmentShaderObject);

Nachdem die Shaderobjekte nun an das Programmobjekt angehängt wurden, werden diese nicht mehr benötigt und ihre Resourcen können freigegeben werden :

glDeleteShader(VertexShaderObject);
glDeleteShader(FragmentShaderObject);

Am Schluß müssen wir dann noch unsere ans Programmobjekt gebundenen Shader linken :

glLinkProgram(ProgramObject);

Während [[glCompileShader]] unsere Shader auf syntaktische Fehler innerhalb ihres lokalen Raums geprüft hat, werden beim Linken durch [[glLinkProgram]] die angehangenen Shader zu einem ausführbaren Shader gelinkt. Folgende Bedingungen führen zu einem '''Linkerfehler''':

* Die Zahl der von der Implementation unterstützten Attributvariablen wurde überschritten
* Der Speicherplatz für Uniformvariablen wurde überschritten
* Die Zahl der von der Implementation angebotenen Sampler wurde überschritten
* Die main-Funktion fehlt
* Die Liste der Varying-Variablen des Vertexshaders stimmt nicht mit der des Fragmentshaders überein
* Funktions- oder Variablenname nicht gefunden
* Eine gemeinsame Globale ist mit unterschiedlichen Werten oder Typen initialisiert worden
* Zwei Sampler unterschiedlichen Typs zeigen auf die selbe Textureneinheit
* Ein oder mehrere angehangene(r) Shader wurden nicht erfolgreich kompiliert

Die Nutzung von glSlang im eigenen Programm ist wie oben erkennbar also nicht wirklich schwer und innerhalb kurzer Zeit realisiert. Natürlich ist es auch möglich z.B. nur einen VertexShader oder nur einen FragmentShader an ein Programmobjekt zu binden.

Noch eine kleine Notiz zum Löschen der Shader mittel [[glDeleteShader]] : Da Shader(objekte) einen Referenzzähler besitzen und erst gelöscht werden wenn diese nirgendwo mehr benötigt werden, ist es nicht falsch diese vor dem Linkvorgang zu löschen. Allerdings spielt es letztendlich keine Rolle ob die Löschanweisung vorher der nachher ausgeführt wird.

==Fehlererkennung==
Natürlich wird es ohne Fehlerausgabe recht schwer, etwaige Probleme in einem Vertex- oder Fragmentshader zu finden. Doch auch in diesem Bereich wurde glSlang recht gut durchdacht und es wurden zwei Funktionen eingeführt, welche im Zusammenspiel die Fehlersuche recht einfach machen, nämlich [[glGetShaderInfoLog]] und [[glGetShader]] mit dem Argument {{INLINE_CODE|GL_OBJECT_INFO_LOG_LENGTH}}. Erstere Funktion liefert uns einen Logstring, während uns letztere Funktion dessen Länge angibt. Der Logstring wird verändert, sobald ein Shader kompiliert oder ein Programm gelinkt wird.

Um die Ausgabe dieses Logs so einfach wie möglich zu machen, bietet es sich an beide in einer einfach Funktion unterzubringen :

<source lang="pascal">function glSlang_GetInfoLog(pShader: GLHandleARB): String;
var
blen, slen: GLInt;
InfoLog: PGLCharARB;

begin
glGetShaderiv(glObject, GL_INFO_LOG_LENGTH , @blen);
if blen > 1 then
begin
GetMem(InfoLog, blen * SizeOf(GLCharARB));
glGetShaderInfoLog(pShader, blen, slen, InfoLog);
Result := PChar(InfoLog);
Dispose(InfoLog);
end;
end;</source>

Die Funktion ist recht leicht erklärt : Zuerst lassen wir uns über {{INLINE_CODE|glGetShaderiv}} mitteilen wie lang der aktuelle Infolog ist. Sollte dort tatsächlich etwas drinstehen (blen > 1), dann lassen wir uns dessen Inhalt via {{INLINE_CODE|glGetShaderInfoLog}} in {{INLINE_CODE|InfoLog}} ausgeben und liefern diesen als Ergebnis zurück.

Wie bereits gesagt wird nur nach dem Kompilieren eines Shaders bzw. dem Linken eines Programmobjektes ein Infolog erstellt. Es bietet sich dadurch an, direkt danach einen solchen Aufruf zu machen :

glCompileShader(VertexShaderObject);
ShowMessage(glSlang_GetInfoLog(VertexShaderObject));

Wenn unser Vertex Shader komplett fehlerfrei kompiliert werden konnte, dann sehen wir als Ergebnis nur einen leeren Dialog. Ist dies nicht der Fall, so werden wir vom Treiber mit recht detaillierten Fehlerinformationen "belohnt", z.B. so :

[[Bild:GLSL_error_vshader.jpg]]

Auch das Infolog nach dem Linken des Programmobjektes dürfte, selbst wenn keine Fehler vorkommen, recht interessant sein, das sieht dann nämlich so aus :

[[Bild:GLSL info programobject.jpg]]

Wie zu sehen, wird uns nach dem erfolgreichen Linken auch gesagt, ob und welcher Shader in Hardware bzw. Software läuft. Für Debuggingzwecke sicherlich eine mehr als brauchbare Information.

==Shader benutzen==
Um den Shader auch für die nächsten Polygone zu benutzen oder Uniformparameter übergeben zu können, ruft man die Funktion
glUseProgramt(ProgramObject);
um alle Shader zu deaktivieren, ruft man dieselbe Funktion mit dem Parameter 0.

==Parameterübergabe==
Uniformparameter (mehr dazu später) stellen die Schnittstelle zwischen eurem Programm und dem Shader dar, werden also genutzt um Daten aus dem Programm heraus an einen Shader zu übergeben. Zur Übergabe dieser Parameter bietet OpenGL diverse Funktionen, die alle Abkömmlinge von [[glUniform]] sind. Während mit {{INLINE_CODE|glUniform4f}} z.B. ein Vier-Komponentenvektor an das Programmobjekt übergeben wird, kann man mittels {{INLINE_CODE|glUniformMatrix4fv}} ganze Matrizen schnell und einfach übergeben. Ausserdem gibt es nun die Möglichkeit Uniformparameter direkt über ihren Namen, statt wie unter ARB_FP/VP über einen festen Index zu adressieren. Die Funktion [[glGetUniformLocationARB]] gibt anhand des übergebenen Parameternamens dessen Position zurück. Man kann also ganz einfach über den Namen drauf zugreifen :

glUniform3f(glGetUniformLocation(ProgramObject, PGLCharARB('LightPosition')), LPos[0], LPos[1], LPos[2]);
glUniform1i(glGetUniformLocation(ProgramObject, PGLCharARB('texSamplerTMU3')), 3);

Wichtig ist hier, das man je nach Parametertyp auch die passende Anzahl von Argumenten übergibt. Also für einen 4-Komponenten Floatvektor {{INLINE_CODE|glUniform4fARB}} und für einen einfachen Integerwert (z.B. Textureinheit für einen Sampler) glUnifrom1iARB. Auch nicht vergessen dürft ihr, das die Namen der Parameter genauso wie im Shader geschrieben werden müssen, also Groß- und Kleinschreibung beachtet werden muß.

=Die Shadersprache=

Nachdem wir uns mit der Einbindung der glSlang-Shader in unser Programm beschäftigt haben, wollen wir uns in den folgenden Kapiteln um die Sprachelemente von glSlang kümmern. Wie schon gesagt basiert glSlang auf ANSI-C, wurde allerdings um speziell auf den Zielbereich angepasste Vektor- und Matrixtypen und einige C++-Features wie das freie deklarieren von Variablen an jeder Stelle und das Funktionsüberladen auf Basis des Argumenttyps erweitert. Wer sich ein wenig mit C/C++ auskennt sollte also in der nun folgenden Materie keine Probleme bekommen.

'''Obligatorische Hinweise für verwöhnte Delphi-Nutzer : '''
*Wie von C/C++ her gewohnt, spielt auch in glSlang die Groß- und Kleinschreibung eine wichtige Rolle, also bitte achtet darauf. gl_Position ist eine komplett andere Variable als z.B. gl_position.
*Es findet keine automatische Typenkonvertierung statt. Das bedeutet also das float MyFloat = 1 ungültig ist und es in dem Falle float MyFloat = 1.0 heissen muss. Typecasts müssen also immer manuell stattfinden, z.B. MyFloat = float(MyInt).

'''Kleine Programmstrukturkunde für C-Unkundige :'''<br>
Da sicherlich einige Delpher nie richtig was mit C gemacht haben, zeige ich mal anhand eines kleinen Beispieles (das auf keinen Fall nen brauchbaren Shader darstellt) den grundlegenden Aufbau eines glSlang-Shaders, der natürlich dem Aufbau eines C-Programmes stark ähnelt :
<source lang="glsl">
uniform vec4 VariableA;
float VariableB;
vec3 VariableC;
const float KonstanteA = 256.0;

float MyFunction(vec4 ArgumentA)
{
float FunktionsVariableA = float(5.0);

return float(ArgumentA * (FunktionsVariableA + KonstanteA));
}

// Ich bin ein Kommentar
/* Und ich auch */
void main(void)
{
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
gl_TexCoord[0] = gl_MultiTexCoord0;
}
</source>

Sieht doch recht bekannt aus, unser Programmaufbau. Delphi und C haben ja so einige Grundlagen gleich, darunter auch der ungefähre Programmaufbau. Ausserhalb jeglicher Funktionen legen wir am Programmanfang unsere Variablen, Konstanten und Attribute fest, die dann ''global'' nutzbar sind, also in jeder Funktion.

Darunter deklarieren wir dann eine kleine Funktion. Wie auch bei den Variablendeklarationen wird hier der Rückgabetyp nicht wie bei Pascal nach dem Funktionsnamen untergebracht, sondern davor. Innerhalb der Funktion können dann wieder Variablen deklariert werden, die dann allerdings ''lokal'', also nur in dieser Funktion nutzbar sind. Vorteil dieser Deklaration ist die Tatsache, dass je nach Grafikkarte nur bestimmt viele globale Variablen deklariert werden können. Wenn möglich sollte man also mit lokalen Vorlieb nehmen. Unsere Funktion gibt dann natürlich noch via return einen Wert zurück, ''was gemacht werden muss'', sofern man diese nicht als void deklariert hat (entspräche dann einer Prozedur in Pascal). Wird dies nicht getan, so spuckt der Compiler einen Fehler aus.

Auch wichtig sind natürlich Kommentare. Erste Variante (Doppelslash) ist auch in der Pascalwelt verfügbar und kommentiert eine einzelne Zeile aus. Die Variante darunter kann man für Kommentarblöcke nutzen (/* .. */) und entspricht den Kommentaren in geschweiften Klammern in Delphi.

Danach kommt dann die '''wichtigste Funktion''' des Shaders, nämlich '''main''', die in keinem Shader fehlen darf. Sie stellt quasi den Programmkörper dar und ist oft auch die einzige Funktion in einem Shader. Sie erhält weder ein Argument, noch gibt sie einen Wert zurück.

Soviel also zum grundlegenden Aufbau eines Shader. Hoffe das jetzt alle die in C nicht so bewandert sind damit klar kommen, und dann bald ihre ersten glSlang-Shader schreiben können.

==Datentypen==

Obwohl einige Datentypen aus C übernommen wurden, sieht man der Typenliste an, das diese speziell auf den 3D-Bereich zugeschnitten wurde. Variablen müssen vor ihrer Nutzung eindeutig deklariert sein, Typecasting erfolgt über Konstruktoren (dazu später mehr). Folgende Datentypen stehen sowohl im Vertex- als auch Fragmentshader zur Verfügung :

{|{{Prettytable_B1}}
!Datentyp
!Erklärung
|-
|void
|Für Funktionen die keinen Wert zurückgeben
|-
|bool
|Konditionaler Typ, entweder true (wahr) oder false (falsch)
|-
|int
|Vorzeichenbehafteter Integerwert
|-
|float
|Fließkommaskalar mit Singlegenauigkeit (32 Bit)
|-
|vec2
|2-Komponenten Fließkommavektor
|-
|vec3
|3-Komponenten Fließkommavektor
|-
|vec4
|4-Komponenten Fließkommavektor
|-
|bvec2
|2-Komponenten Booleanvektor
|-
|bvec3
|3-Komponenten Booleanvektor
|-
|bvec4
|4-Komponenten Booleanvektor
|-
|ivec2
|2-Komponenten Integervektor
|-
|ivec3
|3-Komponenten Integervektor
|-
|ivec4
|4-Komponenten Integervektor
|-
|mat2
|2x2 Fließkommamatrix
|-
|mat3
|3x3 Fließkommamatrix
|-
|mat4
|4x4 Fließkommamatrix
|}

Die sampler-Typen stellen eine besondere Klasse zum Zugriff auf Texturen dar, und werden im Kapitel 6.7 genauer erklärt, inklusive einiger Anwendungsbeispiele.

{|{{Prettytable_B1}}
!Datentyp
!Erklärung
|-
|sampler1D
|Zugriff auf 1D-Textur
|-
|sampler2D
|Zugriff auf 2D-Textur
|-
|sampler3D
|Zugriff auf 3D-Textur
|-
|samplerCube
|Zugriff auf Cubemap
|-
|sampler2DRect
|Zugriff auf Texturen die nicht 2^n * 2^n entsprechen ("non power-of-two", NPOT)
|-
|sampler1DShadow
|Zugriff auf 1D-Tiefentextur mit Vergleichsoperation
|-
|sampler2DShadow
|Zugriff auf 2D-Tiefentextur mit Vergleichsoperation
|-
|samplerCubeShadow
|Zugriff auf Tiefentextur in einer Cubemap (z.b. für omni-diretionale Lichtquellen)
|-
|sampler2DRectShadow
|Zugriff auf 2D-NPOT-Tiefentextur
|-

|sampler1DArray
|Zugriff auf ein array aus 1D-Texturen
|-
|sampler2DArray
|Zugriff auf ein array aus 2D-Texturen
|-
|sampler1DArrayShadow
|Zugriff auf ein array aus 1D-Tiefentexturen
|-
|sampler2DArrayShadow
|Zugriff auf ein array aus 2D-Tiefentexturen
|-
|samplerBuffer
|Zugriff auf eine Puffertextur (1D-Texutr zum Speichern von Pufferobjekten)
|-
|sampler2DMS
|Zugriff auf eine 2D-Textur mit mehreren Samplepunkten (z.b. für Multisampling)
|-
|sampler2DMSArray
|Zugriff auf einarray aus 2D-Textur mit mehreren Samplepunkten (z.b. für Multisampling)
|-
|}

===Arrays===

Natürlich unterstützt glSlang auch Arrays, die wie in C deklariert werden und deren Index bei 0 beginnt. Folgendes Array im Shader :
<source lang="glsl">
float temp[3];
</source>
beginnt also bei Index 0 und endet bei Index 2. Im Gegensatz zu C lassen sich Arrays in glSlang allerdings ''nicht bei der Initialisierung vorbelegen''. Wenn ein Array als Parameter einer Funktion deklariert wird, so darf dieses keine Dimensionierung erhalten.

===Strukturen===

Neu ggü. ARB_FP/VP ist nun auch die Möglichkeit, Strukturen in einem Shader zu deklarieren. Vor allem die Übersicht komplexerer Shader kann dadurch stark verbessert werden. Strukturen werden wie gewohnt mit dem Schlüsselwort {{INLINE_CODE|struct}} eingeleitet und können dann zur Typisierung von Variablen genutzt werden. Folgendes Beispiel dürfte die Nutzung verdeutlichen :
<source lang="glsl">
struct light
{
bool active;
float intensity;
vec3 position;
vec3 color;
};
</source>
Im Shader können dann neue Variablen von diesem Typ ganz einfach deklariert werden :
<source lang="glsl">
light LightSource[3];
</source>
Der Zugriff auf die Elemente der Struktur erfolgt dann wie gewohnt über den Punkt :
<source lang="glsl">
LightSource[i].position = vec3(1.0, 1.0, 5.0);
</source>

==Typenqualifzierer==

Zusätzlich zur Typendeklaration kann eine Variable noch einen Typenqualifizerer vorangestellt bekommen, der an den Anfang der Deklaration gehört.

* '''const'''
: Festgelegte (nur lesen) Konstante bzw. nur lesbarer Funktionsparameter.

* '''uniform'''
: Ein den ganzen Shader über gleichbleibender Wert, der eine Schnittstelle zwischen dem Shader und der OpenGL-Anwendung darstellt. Ein Uniformwert wird in der Hauptanwendung an den entsprechenden Shader übergeben und kann dort dann genutzt werden.

* '''attribute'''
: Nur lesbare Werte die eine Verbindung zwischen dem Shader und der OpenGL-VertexAPI darstellen (z.B. VertexParameter eines VertexArrays). Natürlich nur in einem Vertex Shader nutzbar.

* '''varying'''
: Stellt die Verbindung zwischen einem Vertex- und einem FragmentShader dar. Werden im VertexShader geschrieben und dann perspektivisch korrekt über die Primitive interpoliert, um dann im Fragment Shader gelesen werden zu können. Nutzbar sind hier nur die Typen float, vec2, vec3, vec4, mat2, mat3 und mat4, Strukturen und andere Datentypen können nicht varying sein. Die Namen einer varying-Variable müssen sowohl im VertexShader als auch im FragmentShader gleich sein.

* '''in'''
: Für Variablen die an eine Funktion übergeben und dort ausgelesen werden.

* '''out'''
: Für Variablen die von einer Funktion nach aussen zurückgegeben werden.

* '''inout'''
: Für Variablen die sowohl an eine Funktion übergeben als auch von dieser zurückgegeben werden.

Um obige Auflistung nicht leer im Raum stehen zu lassen zeige ich ein paar Beispiele die hoffentlich zum Verständnis beitragen :

===Beispiel A===
Vertexnormale soll an einen FragmenShader (interpoliert) übergeben werden :

:Im VertexShader :
<source lang="glsl">
varying vec3 VertexNormal;
...
VertexNormal = normalize(MV_IT * gl_Normal);
</source>
:Im FragmentShader :
<source lang="glsl">
varying vec3 VertexNormal;
...
TempVector = VertexNormal*...
</source>

===Beispiel B===
Uniformparameter zur nachträglichen Farbänderung der Szene wird im Programm übergeben :

:Im VertexShader :
<source lang="glsl">
uniform vec4 GlobalColor;
...
gl_FrontColor = GlobalColor * gl_Color;
</source>
:Im Programm :

glUniform4fARB(glSlang_GetUniLoc(ProgramObject, 'GlobalColor'), Col[0], Col[1], Col[2], Col[3]);

===Beispiel C===
Konstante zur festen Farbänderung :

:Im VertexShader :
<source lang="glsl">
const vec4 ColorBias = vec4(0.2, 0.3, 0.0, 0.0);
...
gl_FrontColor = ColorBias * gl_Color;
</source>
==Konstruktoren==

Um in einem Shader ''Vektoren'' oder ''Matrizen'' mit Werten zu belegen, gibt es sogenannte Konstruktoren (nicht zu verwechseln mit z.B. Klassenkonstruktoren unter Delphi), die im Endeffekt nichts anderes als Funktionen zur Vorbelegung von Vektoren oder Matrizen darstellen. Dabei trägt der Konstruktor den selben Namen wie die Typendeklaration, also lässt sich eine Variable vom Typ {{INLINE_CODE|vec4}} mit dem Konstruktor {{INLINE_CODE|vec4(float, float, float, float)}} initialisieren.

Allerdings hat man sich recht viel Mühe bei dieser Konstruktorgeschichte gemacht, so dass man einen vec4 nicht unbedingt mit einem {{INLINE_CODE|vec4}}-Konstruktor vorbelegen muss, sondern es vielseitige Möglichkeiten gibt. Um dies zu verdeutlichen gibts ein paar Beispiele :
<source lang="glsl">
vec4 Color = vec4(1.0, 0.0, 0.0, 0.0);
vec4 Color = vec4(MyVec3, 1.0);
vec4 Color = vec4(MyVec2_A, MyVec2_B);

vec3 LVec = vec3(MyVec4);
vec2 Tmp = vec2(MyVec3);
</source>

Trotz der recht wenigen Beispiele sollte schnell erkennbar sein, das man hier wirklich sehr viele Kombinationsmöglichkeiten hat, die dann gültig sind ''wenn man mindestens auf die benötigte Anzahl der Argumente kommt''. Im vorletzten Beispiel wird z.B. ein 3-Komponentenvektor aus einem 4-Komponentenvektor initialisiert. Das erzeugt keinen Fehler, sondern führt dazu das {{INLINE_CODE|vec3.x, vec3.y, vec3.z}} aus MyVec4 übernommen werden und MyVec4.w einfach ignoriert wird.

Das Umkehrbeispiel, also
<source lang="glsl">
vec4 Color = vec4(MyVec3)
</source>
funktioniert allerdings nicht, da hier die Zahl der benötigten Argumente nicht erreicht wird. In diesem Falle müsste es dann
<source lang="glsl">
vec4 Color = vec4(MyVec3, 0.0)
</source>
heissen.

Obiges gilt natürlich auch für ''Matrixkonstruktoren'', hier sind z.B. folgende Konstuktoren denkbar, obwohl eigentlich alle Möglichkeiten nutzbar sind, ''solange die benötigte Zahl an Argumenten erreicht wird'' :
<source lang="glsl">
mat4 MyMatrix = mat4(MyVec4, MyVec4, MyVec4, MyVec4);
mat2 MyMatrix = mat4(1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0);
</source>

==Vektor- und Matrixkomponenten==

Was natürlich in keiner Shadersprache fehlen darf, ist der leichte Zugriff auf die einzelnen Komponenten eines Vektors. glSlang bietet, je nach Anwendungsgebiet gleich drei Namensets für den Zugriff auf die Komponenten eines solchen Vektors, welches Set man nutzen will bleibt natürlich frei und ist unabhängig von der Deklaration eines Vektors. Man sollte nur darauf achten, beim gleichzeitigen Zugriff auf mehrere Komponenten im gleichen Namenset zu verbleiben :

* {x, y, z, w}
:Für den Zugriff auf Vektoren die Punkte, Normale oder sonstige Vertexdaten repräsentieren.

* {r, g, b, a}
:Für den Zugriff auf Vektoren die Farbwerte repräsentieren.

* {s, t, p, q}
:Für den Zugriff auf Vektoren die Texturkoordinaten repräsentieren.

Ein paar Beispiele zur Unterstreichung des oben gesagten :
<source lang="glsl">
v4.rgba = vec4(1.0, 0.0, 0.0, 0.0); // gültig
v4.rgzw = vec4(1.0, 1.0, 1.0, 2.0); // Ungültig, da verschiedenen Namensets
v2.rgb = vec3(1.0, 2.0, 1.0); // Ungültig, da vec2 nur r+g besitzt
v2.xx = vec2(5.0, 3.0); // Ungültig, da 2 mal gleiche Komponente
</source>

Auch der Zugriff auf die Komponenten einer Matrix geht leicht von der Hand. Namensets wie bei den Vektoren gibt es hier natürlich keine, aber folgende Beispiele sollen den Zugriff aufzeigen :
<source lang="glsl">
MyMat4[2] = vec4(1.0); // Setzt die 3.Zeile der Matrix komplett auf 1.0
MyMat4[3][3] = 3.5; // Setzt das Element unren rechts auf 3.5
</source>

Ein Zugriff auf Matrixelemente ausserhalb ihrer Dimension (also z.B. MyMat4[4][4]) liefert unvorhersehabre Ergebnise, also sollte man auf diese Fälle prüfen.

==Vektor- und Matrixoperationen==

Wie von C gewohnt sind in glSlang so ziemlich alle Operatoren die man auf Matrizen oder Vektoren anwenden kann überladen, so das man nicht umständlich über selbstgeschriebene Funktionen kombinieren muss. Darüber hinaus ist es in den meisten Fällen auch möglich ohne Konvertierung Fließkommawerte mit kompletten Matrizen oder Vektoren zu kombinieren. Folgende Beispiele zeigen einige der vielfältigen Kombinationsmöglichkeiten auf :
<source lang="glsl">
vec3 dest;
vec3 source;
float factor;

vec3 dest = source + factor;

// Ist gleich
dest.x = source.x + factor;
dest.y = source.y + factor;
dest.z = source.z + factor;
</source>

Matrix * Vektor ist auch ohne manuelle Konvertierung möglich :
<source lang="glsl">
vec3 dest;
vec3 source;
mat3 MyMat;

dest = source * MyMat;

// Ist gleich
dest.x = dot(source, MyMat[0]);
dest.y = dot(source, MyMat[1]);
dest.z = dot(source, MyMat[2]);
</source>

Auch hier sind die Möglichkeiten fast unbeschränkt und zeigen wieder wie flexibel glSlang ausgelegt ist.

==Operatoren==

glSlang bietet (momentan) folgende Operatoren, die Liste ist nach ihrer Gewichtung sortiert (Anfang = höchste). Alle ''reservierten'' Operatoren werden erst in kommender Hardware/glSlang-Versionen nutzbar sein :

<div align="center">
{|{{Prettytable_B1}}
!Operatorklasse
!Operatoren
!Assoziation
|-
|Gruppering
|()
| -
|-
|Arrayindizierung<br>Funktionsaufrufe und Konstruktoren<br>Strukturfeldwahl und Swizzle<br>Postinkrement und -dekrement<br>
|[]<br>()<br>.<br>++ --
|Links n. Rechts
|-
|Prefixinkrement- und dekrement<br>Einheitlich (~ reserviert)
| ++ --<br> + - ~ !
|Rechts n. Links
|-
|Mulitplikation (% reserviert)
|* / %
|Links n. Rechts
|-
|Additiv
| + -
|Links n. Rechts
|-
|Bitweises Verschieben (reserviert)
|<< >>
|Links n. Rechts
|-
|Relation
|< > <= >=
|Links n. Rechts
|-
|Vergleich
|== !=
|Links n. Rechts
|-
|Bitweises AND (reserviert)
|&
|Links n. Rechts
|-
|Bitweises XOR (reserviert)
|^
|Links n. Rechts
|-
|Bitweises OR (reserviert)
| <nowiki>|</nowiki>
|Links n. Rechts
|-
|Logisches AND
|&&
|Links n. Rechts
|-
|Logisches XOR
|^^
|Links n. Rechts
|-
|Logisches OR
| <nowiki>||</nowiki>
|Links n. Rechts
|-
|Auswahl
|?:
|Rechts n. Links
|-
|Zuweisung<br>Arithmetrische Zuweisung<br>(Modulis, Shift und bitweise Op. reserviert)
|<nowiki>=</nowiki><br> <nowiki>+= -= *= /= %=</nowiki> <br> <nowiki><<= >>= &= ^= |=</nowiki>
|Rechts n. Links
|-
|Aufzählung
|,
|Links n. Rechts
|-
|}
</div>

==Funktionen==

Ein großer Vorteil von Hochsprachen ist u.A. die Möglichkeit oft genutzte Codeteile in Funktionen (bzw. auch Prozeduren unter Pascal) zu verpacken um so Flexibilität als auch Übersichtlichkeit zu steigern. Wer schonmal was in C geschrieben hat, der wird sich jetzt sicherlich kein Kopfzerbrechen machen müssen. Funktionen werden in glSlang genauso nach folgendem Prinzip deklariert :
<source lang="glsl">
RückgabeTyp FunktionsName(Typ0 Argument0, Typ1, Argument1, ... , TypN, ArgumentN)
{
return RückgabeWert;
}
</source>

Funktionen die ''nichts zurückgeben'' müssen mit dem RückgabeTyp {{INLINE_CODE|void}} deklariert werden, ausserdem entfällt dann logischerweise das {{INLINE_CODE|return}}. Falls die Funktion eines ihrere Argumente nach aussen übergeben soll, muss dieses Argument mit dem Typenqualifizierer out (Siehe Kapitel 4.2) versehen werden. ''Arrays'' können nur als Eingabeargumente übergeben werden und dürfen nich dimensioniert als Argument verwendet werden, sondern müssen mit leeren Klammern argumentiert werden.
Ein paar Beispiele :
<source lang="glsl">
void MeineFunktion(float EingabeWert; out float AusgabeWert)
{
AusgabeWert = EingabeWert*MyConstValue;
}
</source>

Diese Funktion gibt ''nichts'' zurück, aber gibt EingabeWert*MyConstValue im Ausgabeargument AusgabeWert nach aussen.
<source lang="glsl">
float MeineFunktion(float EingabeWert)
{
return EingabeWert*MyConstValue;
}
</source>

Bietet genau die selbe Funktionalität wie das Beispiel darüber. Allerdings wird hier der berechnete Wert als Ergebnis der Funktion zurückgeliefert.
<source lang="glsl">
float VektorSumme(float v[])
{
return v[0]+v[1]+v[2]+v[3];
}
</source>

Wie bereits gesagt darf ein Array als Argument keine Dimensionierung enthalten. Wenn man der Funktion also ein Array übergibt, sollte man vorher drauf achten das es entsprechend der in der Funktion genutzten Indizes dimensioniert wurde.

==if-Anweisung==

Selektion über eine if-Anweisung darf auch in keiner Hochsprache fehlen. Genauso wie in C oder Delphi erwartet auch hier die If-Anweisung einen boolschen Ausdruck (Wahr oder Falsch) und wird dann ausgeführt (wahr) bzw. verzweigt auf ein (wenn vorhanden) else (falsch). Verschachtelung ist wie erwartet auch möglich.

'''Hinweis : '''
Grafikkarten auf dem Stand des Shadermodells 2.0 (Radeon 9x00, Radeon X8x0, GeForceFX 5x00) unterstüzten im Fragmentshader kein Early-Out, was zur Folge hat das bei einer If-Anweisung immer alle Zweige ausgeführt werden. Am Ende wird dann aber nur ein Ergebnis geschrieben, die anderen verworfen. Auf solchen Karten bringen If-Anweisungen also im Normalfall keine Geschwindigkeitssteigerung, sondern oft eher das Gegenteil.
Neuere SM3.0-Karten (Radeon X1x00, GeForce6x00 und höher) ist dass nicht mehr der Fall, da hier dynamische Verzweigungen und auch Early-Out von der Hardware implementiert werden.

==Schleifen==

Auch Schleifen, ein wichtiges Konzept jeder Hochsprache haben ihren Weg in glSlang gefunden. Unterstützt werden folgende Schleifentypen :

* '''for'''-Schleife
<source lang="glsl">
for (Startausdruck; Durchlaufbedingung; Wiederholungsausdruck)
{
statement
}
</source>

* '''while'''-Schleife
<source lang="glsl">
while (Durchlaufbedingung)
{
statement
}
</source>

* '''do'''-while-Schleife
<source lang="glsl">
do
{
statement
}
while (Durchlaufbedingung)
</source>

'''Hinweis :''' Grafikkarten auf dem Stand des Shadermodells 2.0 (Radeon 9x00, Radeon X8x0, GeForceFX 5x00) unterstüzten Schleifen nicht in Hardware. Schleifen werden dann beim Kompilieren vom Treiber entrollt, wodurch natürlich Shader mit weitaus mehr Instruktionen als erwartet generiert werden. Von daher sollte man auf solchen Karten möglichst auf Schleifen verzichten, oder diese nur recht kurz halten. Bei SM3.0-Karten (Radeon X1x00, GeForce6x00 und höher) ist dass nicht mehr der Fall.

=Eingebaute Variablen, Attribute und Konstanten=
Nachdem wir uns nun lange genug mit den minderinterssanten Elementen der glSlang-Syntax beschäftigt haben, gehts jetzt endlich an die wirklich interessanten Dinge. Wie schon ARB_VP/ARB_FP bringt auch glSlang jede Menge eingabauter Variablen, Attribute und Konstanten mit, deren Aliase sie recht leicht identifizierbar machen (ganz im Gegensatz zum Indexgewusel bei den DX-Shadern).

==Variablen im Vertex Shader==
Exklusiv im Vertex Shader stehen die folgenden Variablen zur Verfügung :

* vec4 gl_Position muss geschrieben werden
:Dieser Variable '''muss''' im Vertexshader ein Wert zugewiesen werden, wird dies nicht getan ist das Ergebnis (sprich die Position des Vertex) undefiniert. Vorgesehen ist diese Variable für die ''homogene Position des Vertex'' und wird u.a. zum Clipping und Culling verwendet. Sie darf natürlich auch (mehrfach) geschrieben und ausgelesen werden.

* float gl_PointSize kann geschrieben werden
:Diese Variable wurde dazu vorgesehen um dort im VertexShader die Punktgröße in Pixeln hineinzuschreiben.

* vec4 gl_ClipVertex kann geschrieben werden
:Falls genutzt, sollten hier die Vertexkoordinaten die im Zusammenhang mit benutzerdefinierten Clippingplanes genutzt werden abgelegt werden. Wichtig ist, das gl_ClipVertex im selben Koordinatenraum wie die Clippingplane definiert ist.

==Attribute im Vertex Shader==

Folgende Attribute stehen nur im Vertex Shader zur Verfügung und '''können nur gelesen werden''' :

* vec4 gl_Color
: Farbwert des Vertex.
* vec4 gl_SecondaryColor
:Sekundärer Farbwert des Vertex.
* vec4 gl_Normal
:Normale des Vertex.
* vec4 gl_Vertex
:Koordinaten des Vertex;
* vec4 gl_MultiTexCoord0..7
:Texturkoordinaten auf Textureinheit 0..7.
* float gl_FogCoord
:Nebelkoordinate des Vertex.

==Variablen im Fragment Shader==

Im Fragment Shader sind folgende Variablen exklusiv nutzbar :

* vec4 gl_FragColor
: Speichert den Farbwert des Fragmentes, der von folgenden Funktionen der festen Pipeline genutzt wird. Wird dieser Variable nichts zugewiesen, so ist ihr Inhalt undefiniert und darauf aufbauende Ergebnisse ebenfalls.

* vec4 gl_FragData[0..15]
: Ersetzt gl_FragColor bei der Verwendung von multiplen Rendertargets.

* float gl_FragDepth
: Durch schreiben dieser Variable kann man den von der festen Funktionspipeline ermittelten Tiefenwert überspringen, der mit {{INLINE_CODE|gl_FragCoord.z}} ausgelesen werden kann. Wird dieser Wert nicht geschrieben, nutzen folgende Funktionen der Pipeline den vorher fest berechneten Wert.

* vec4 gl_FragCoord nur lesen
: In dieser Variable ist die Position des Fragmentes relativ zur Fensterposition im Format x,y,z,1/w abgelegt, wobei z den von der festen Funktionspipeline berechneten Tiefenwert enthält.

* bool gl_FrontFacing nur lesen
: Gibt an ob das Fragment zu einer nach vorne zeigenden Primitive gehört (=true).

Im Bezug auf {{INLINE_CODE|gl_FragColor}} und {{INLINE_CODE|gl_FragDepth}} sei noch anzumerken das diese ''nicht'' in den Wertebereich 0..1 gebracht werden müssen, da dies später durch die feste Funktionspipeline automatisch gemacht wird.

==Eingebaute Varyings==

Wie bereits in Kapitel 4.2 erwähnt, stellen Varyings eine Schnittstelle zwischen dem Vertex und dem Fragment Shader dar. Sie werden im Vertex Shader geschrieben und können dann im Fragment Shader ausgelesen werden, ohne das die folgenden Varyings dafür explizit deklariert werden müssen :

* vec4 gl_FrontColor
: Farbe der Vorderseite des Vertex.

* vec4 gl_BackColor
: Farbe der Rückseite des Vertex.

* vec4 gl_FrontSecondaryColor
: Sekundäre Farbe der Vorderseite des Vertex.

* vec4 gl_BackSecondaryColor
: Sekundäre Farbe der Rückseite des Vertex.

* vec4 gl_TexCoord[x]
: Texturkoordinaten des Vertex auf Textureinheit x, wobei x die von der Hardware zur Verfügung gestellte Zahl der Textureinheiten-1 nicht überschreiten darf.

* float gl_FogFragCoord
: Nebelkoordinate des Fragmentes.

Die Varyings {{INLINE_CODE|gl_FrontColor, gl_FrontSecondaryColor, gl_BackColor}} und {{INLINE_CODE|gl_BackSecondaryColor}} können im FragmentShader nur unter den Aliases gl_Color bzw. gl_SecondaryColor gelesen werden. Welcher Wert des Vertex Shaders im Fragment Shader dort eingesetzt wird ist abhängig davon ob das Fragment zu einer nach vorne oder nach hinten zeigenden Primitive gehört.

==Eingebaute Konstanten==
Auch diverse Konstanten wurden definiert um darauf schnell im Shader zugreifen zu können. In den Klammern stehen die von einer GL-Implementation als Mindestanforderung anzubietenden Werte. Alle Konstanten sind sowohl im Vertex als auch im Fragment Shader abrufbar :

: OpenGL 1.0/1.2 :
* int gl_MaxLights (8)
* int gl_MaxClipPlanes (6)
* int gl_MaxTextureUnits (2)

: ARB_Fragment_Program :
* int gl_MaxTextureCoordsARB (2)

: Vertex_Shader :
* int gl_MaxVertexAttributesGL2 (16)
* int gl_MaxVertexUniformFloatsGL2 (512)
* int gl_MaxVaryingFloatsGL2 (32)
* int gl_MaxVertexTextureUnitsGL2 (1)

: Fragment_Shader :
* int gl_MaxFragmentTextureUnitsGL2 (2)
* int gl_MaxFragmentUniformFloatsGL2 (64)

==Eingebaute Uniformvariablen==

Um den Zugriff auf OpenGL-Staten zu vereinfachen wurden in glSlang diverse Uniformvariablen zur direkten Verwendung im Shader eingebaut. Wie gewohnt wurden auch hier sinnvolle Namen verwendet, so dass eine tiefere Erklärung unnötig sein dürfte :

* mat4 gl_ModelViewMatrix
* mat4 gl_ProjectionMatrix
* mat4 gl_ModelViewProjectionMatrix
* mat3 gl_NormalMatrix
:{{INLINE_CODE|gl_NormalMatrix}} repräsentiert die invertierten und anschließend transponierten oberen 3x3 Werte der {{INLINE_CODE|gl_ModelViewMatrix}}.
* mat4 gl_TextureMatrix[gl_MaxTextureCoordsARB]

* float gl_NormalScale
: Gibt den unter OpenGL festgelegten Faktor zur Skalierung der Normalen zurück.

* struct gl_DepthRangeParameters
<source lang="glsl">
struct gl_DepthRangeParameters
{
float near;
float far;
float diff;
};
gl_DepthRangeParameters gl_DepthRange;
</source>
: Clippingplanes :
* vec4 gl_ClipPlane[gl_MaxClipPlanes]

*struct gl_PointParameters
<source lang="glsl">
struct gl_PointParameters
{
float size;
float sizeMin;
float sizeMax;
float fadeThresholdSize;
float distanceConstantAttenuation;
float distanceLinearAttenuation;
float distanceQuadraticAttenuation;
};
gl_PointParameters gl_Point;
</source>
*struct gl_MaterialParameters
<source lang="glsl">
struct gl_MaterialParameters
{
vec4 emission;
vec4 ambient;
vec4 diffuse;
vec4 specular;
float shininess;
};
gl_MaterialParameters gl_FrontMaterial;
gl_MaterialParameters gl_BackMaterial;
</source>
*struct gl_LightSourceParameters
<source lang="glsl">
struct gl_LightSourceParameters
{
vec4 ambient;
vec4 diffuse;
vec4 specular;
vec4 position;
vec4 halfVector;
vec3 spotDirection;
float spotExponent;
float spotCutoff;
float spotCosCutoff;
float constantAttenuation;
float linearAttenuation;
float quadraticAttenuation;
};
gl_LightSourceParameters gl_LightSource[gl_MaxLights];
</source>
*struct gl_LightModelParameters
<source lang="glsl">
struct gl_LightModelParameters
{
vec4 ambient;
};
gl_LightModelParameters gl_LightModel;
</source>
*struct gl_LightModelProducts
<source lang="glsl">
struct gl_LightModelProducts
{
vec4 sceneColor;
};
gl_LightModelProducts gl_FrontLightModelProduct;
gl_LightModelProducts gl_BackLightModelProduct;
</source>
*struct gl_LightProducts
<source lang="glsl">
struct gl_LightProducts
{
vec4 ambient;
vec4 diffuse;
vec4 specular;
};
gl_LightProducts gl_FrontLightProduct[gl_MaxLights];
gl_LightProducts gl_BackLightProduct[gl_MaxLights];
</source>
* vec4 gl_TextureEnvColor[gl_MaxFragmentTextureUnitsGL2]
* vec4 gl_EyePlaneS[gl_MaxTextureCoordsARB]
* vec4 gl_EyePlaneT[gl_MaxTextureCoordsARB]
* vec4 gl_EyePlaneR[gl_MaxTextureCoordsARB]
* vec4 gl_EyePlaneQ[gl_MaxTextureCoordsARB]
* vec4 gl_ObjectPlaneS[gl_MaxTextureCoordsARB]
* vec4 gl_ObjectPlaneT[gl_MaxTextureCoordsARB]
* vec4 gl_ObjectPlaneR[gl_MaxTextureCoordsARB]
* vec4 gl_ObjectPlaneQ[gl_MaxTextureCoordsARB]

*struct gl_FogParameters
<source lang="glsl">
struct gl_FogParameters
{
vec4 color;
float density;
float start;
float end;
float scale;
};
gl_FogParameters gl_Fog;
</source>
Diese recht umfangreiche GL-Stateliste sollte eigentlich jeden Bedarf decken und momentan gibts kaum einen OpenGL-Status den man so nicht in einem Shader abfragen bzw. nutzen kann.

=Eingebaute Funktionen=
glSlang ist mit diversen Skalar- und Vektorfunktionen ausgestattet, die teilweise (idealerweise) sogar direkt in der Hardware ausgeführt werden, weshalb einer fertigen Funktion ggü. gleichwertigen eigenen Berechnungen immer der Vorzug zu geben ist.
{{Hinweis| ''genType'' kann vom Type float, vec2, vec3 oder vec4 sein, ''mat'' vom Typ mat2, mat3 oder mat4.}}

==Trigonometrie und Winkel==
Alle übergebenen Winkel sollten, soweit nicht anders vermerkt, in Radien angegeben werden.

* genType radians (genType degrees)
: Wandelt von Grad nach Radien.
* genType degrees (genType radians)
: Wandelt von Radien nach Grad.
* genType sin (genType angle)
: Gibt den Sinus von Angle zurück, wobei Angle in Radien angegeben wird.
* genType cos (genType angle)
: Gibt den Cosinus von Angle zurück, wobei Angle in Radien angegeben wird.
* genType tan (genType angle)
: Gibt den Tangens von Angle zurück, wobei Angle in Radien angegeben wird.
* genType asin (genType x)
: Liefert den Arcsinus von x zurück, also den Winkel dessen Sinus x ergeben würde.
* genType acos (genType x)
: Liefert den Arccosinus von x zurück, also den Winkel dessen Cosinus x ergeben würde.
* genType atan (genType y, genType x)
: Liefert den Winkel zurück, dessen Tangens x/y ergeben würde.
* genType atan (genType y_over_x)
: Liefert den Winkel zurück, dessen Tangens x über y ergeben würde.

==Exponentiell==
* genType pow (genType x, genType y)
: Gibt x hoch y zurück.
* genType exp2 (genType x)
: Gibt 2 hoch x zurück.
* genType log2 (genType x)
: Gibt den Logarithmus zur Basis 2 von x zurück.
* genType sqrt (genType x)
: Gibt die Wurzel von x zurück.
* genType inversesqrt (genType x)
: Gibt die umgekehrte Wurzel von x zurück.

==Standardfunktionen==
* genType abs (genType x)
: Liefert den absoluten Wert von x zurück.
* genType sign (genType x)
: Gibt -1.0 zurück, wenn x < 0.0, 0.0 wenn x = 0.0 und 1.0 wenn x > 0.0.
* genType floor (genType x)
: Gibt denn nächsten Integerwert zurück, der kleiner oder gleich x ist.
* genType ceil (genType x)
: Gibt den nächsten Integerwert zurück, der größer oder gleich x ist.
* genType fract (genType x)
: Gibt den Nachkommateil von x zurück.
* genType mod (genType x, float y)
* genType mod (genType x, genType y)
: Gibt den Modulus zurück. (=x-y * floor(x/y))
* genType min (genType x, genType y)
* genType min (genType x, float y)
: Liefert y zurück wenn y < x, ansonsten x.
* genType max (genType x, genType y)
* genType max (genType x, float y)
: Liefert y zurück wenn x < y, ansonsten x.
* genType clamp (genType x, genType minVal, genType maxVal)
* genType clamp (genType x, float minVal, float maxVal)
: Zwängt x in den Bereich minVal..maxVal.
* genType mix (genType x, genType y, genType a)
* genType mix (genType x, genType y, float a)
: Liefert den linearen Blend zwischen x und y zurück. (= x * (1-a) + y * a)
* genType step (genType edge, genType x)
* genType step (float edge, genType x)
: Liefert 0.0 zurück, wenn x < edge, ansonsten 1.0.
* genType smoothstep (genType edge0, genType edge1, genType x)
* genType smoothstep (float edge0, float edge1, genType x)
: Liefert 0.0 zurück, wenn x <= edge0 und 1.0 wenn x >= edge1. Dabei wird eine weiche Hermite Interpolation zwischen 0 und 1 durchgeführt.

==Geometrie==
* float length (genType x)
: Gibt die Länge des Vektors x (= sqrt(x[0]² + x[1]² + ... + x[n]²) zurück.
* float distance (genType p0, genType p1)
: Gibt die Distanz zwischen den zwei Vektoren p0 un p1 (= length(p0-p1)) zurück.
* float dot (genType x, genType y)
: Gibt das Punktprodukt von x und y zurück (=x[0]*y[0] + x[1]*y[1] + ... + x[n]*y[n]).
* vec3 cross (vec3 x, vec3 y)
: Gibt das Kreuzprodukt von x und y zurück.
* genType normalize (genType x)
: Normalisiert den Vektor x auf die Länge 1.
* vec4 ftransform()
: Nur im Vertex Shader. Die Funktion stellt sicher, das das eingehende Vertex haargenau so transformiert wird wie in der festen Funktionspipeline. gl_Position = ftransform() wird dann also gebraucht, wenn in mehreren Durchgängen sowohl im Shader als auch in der festen Pipeline gerendert wird, um sicherzustellen das in beiden Fällen die gleiche Vertexposition herauskommt.
* genType faceforward (genType N, genType I, genType Nref)
: Gibt einen nach vorne zeigenden Vektor N zurück. (If dot(NRef, I) < 0 return N else return -N)
* genType reflect (genType I, genType N)
: Gibt den an der Flächenausrichtung N reflektierten Vektor I zurück. (=I-2 * dot(N,I) * N)

==Matrixfunktionen==
* mat matrixCompMult (mat x, mat y)
: Multipliziert Matrix X mit Matrix Y komponentenweise. Um eine normale lineare Matrixmultiplikation durchzuführen, sollte der "*"-Operator genutzt werden.

==Vektorvergleiche==
Die meisten Vektorvergleichsfunktionen liefern als Ergebnis einen boolvektor zurück, da die Vergleiche per Komponente stattfinden. Wenn man also x = vec4(1.0, 3.0, 0.0, 0.0) mit y = vec4(2.0, 1.5, 1.5, 0.0) via lessThan(x, y) vergleicht, erhält man als Ergebnis bvec(true, false, true, false).

* bvec lessThan (vec x, vec y)
* bvec lessThan (ivec x, ivec y)
: Gibt den komponentenweisen Vergleich x < y zurück.
* bvec lessThanEqual (vec x, vec y)
* bvec lessThanEqual (ivec x, ivec y)
: Gibt den komponentenweisen Vergleich x <= y zurück.
* bvec greaterThan (vec x, vec y)
* bvec greaterThan (ivec x, ivec y)
: Gibt den komponentenweisen Vergleich x > y zurück.
* bvec greaterThanEqual (vec x, vec y)
* bvec greaterThanEqual (ivec x, ivec y)
: Gibt den komponentenweisen Vergleich x >= y zurück.
* bvec equal (vec x, vec y)
* bvec equal (ivec x, ivec y)
* bvec equal (bvec x, bvec y)
: Gibt den komponentenweisen Vergleich x == y zurück.
* bvec notEqual (vec x, vec y)
* bvec notEqual (ivec x, ivec y)
* bvec notEqual (bvec x, bvec y)
: Gibt den komponentenweisen Vergleich x != y zurück.
* bool any (bvec x)
: Liefert true zurück, wenn mindestens eine der Komponenten von x true ist.
* bool all (bvec x)
: Liefert true zurück, wenn alle Komponenten von x true sind.
* bvec not (bvec x)
: Liefert die logische Negation von x zurück.

==Texturenzugriffe==

Diese wichtige Funktionskategorie dient dazu, Werte aus einer an eine Textureinheit gebundenen Textur zu ermitteln. Die Texturenzugriffe können sowohl im Vertex (!) als auch im Fragment Shader ausgeführt werden, wobei der optionale Parameter bias im Vertex Shader ignoriert wird. Allerdings gibt es zusätzlich Funktionen die auf "Lod" enden und nur im Vertex Shader genutzt werden dürfen um eben dieses Manko zu umgehen. Funktionen mit dem Suffix "Proj" geben einen projizierten Texturenwert zurück.

: '''1D-Texturen :'''
* vec4 texture1D (sampler1D sampler, float coord [, float bias])
* vec4 texture1DProj (sampler1D sampler, vec2 coord [, float bias])
* vec4 texture1DProj (sampler1D sampler, vec4 coord [, float bias])
: Nur im Vertex Shader :
* vec4 texture1DLod (sampler1D sampler, float coord, float lod)
* vec4 texture1DProjLod (sampler1D sampler, vec2 coord, float lod)
* vec4 texture1DProjLod (sampler1D sampler, vec4 coord, float lod)

: '''2D-Texturen :'''
* vec4 texture2D (sampler2D sampler, vec2 coord [, float bias])
* vec4 texture2DProj (sampler2D sampler, vec3 coord [, float bias])
* vec4 texture2DProj (sampler2D sampler, vec4 coord [, float bias])
: Nur im Vertex Shader :
* vec4 texture2DLod (sampler2D sampler, vec2 coord, float lod)
* vec4 texture2DProjLod (sampler2D sampler, vec3 coord, float lod)
* vec4 texture2DProjLod (sampler2D sampler, vec4 coord, float lod)

: '''3D-Texturen :'''
* vec4 texture3D (sampler3D sampler, vec3 coord [, float bias])
* vec4 texture3DProj (sampler3D sampler, vec4 coord [, float bias])
: Nur im Vertex Shader :
* vec4 texture3DLod (sampler3D sampler, vec3 coord, float lod)
* vec4 texture3DProjLod (sampler3D sampler, vec4 coord, float lod)

: '''Cubemap :'''
* vec4 textureCube (samplerCube sampler, vec3 coord [, float bias])
: Nur im Vertex Shader :
*vec4 textureCubeLod (samplerCube sampler, vec3 coord, float lod)

: '''Tiefentextur (Shadowmap) :'''
* vec4 shadow1D (sampler1DShadow sampler, vec3 coord [, float bias])
* vec4 shadow2D (sampler2DShadow sampler, vec3 coord [, float bias])
* vec4 shadow1DProj (sampler1DShadow sampler, vec4 coord [, float bias])
* vec4 shadow2DProj (sampler2DShadow sampler, vec4 coord [, float bias])
: Nur im Vertex Shader :
* vec4 shadow1DLod (sampler1DShadow sampler, vec3 coord, float lod)
* vec4 shadow2DLod (sampler2DShadow sampler, vec3 coord, float lod)
* vec4 shadow1DProjLod (sampler1DShadow sampler, vec4 coord, float lod)
* vec4 shadow2DProjLod (sampler2DShadow sampler, vec4 coord, float lod)

Wie bereits eingangs gesagt ist dieses Kapitel ein sehr wichtiges, denn eine 3D-Szene ohne Texturen ist heute kaum denkbar. Darüber hinaus lassen sich durch Texturenzugriffe recht viele interessante Sachen machen, z.B. ein einfacher Blurfilter oder das freie überblenden bestimmter Texturenteile. Deshalb führe ich hier kurz ein paar Beispiele an, welche die Nutzung dieser Funktionen verdeutlichen sollen :

===Beispiel A===
Eine Textur gebunden die einfach ausgegeben werden soll

''Im Vertex Shader'' :
<source lang="glsl">
void main(void)
{
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
gl_TexCoord[0] = gl_MultiTexCoord0;
}
</source>
Der Vertex Shader ist recht minimal. Neben der homogenen Vertexposition leiten wir hier nur die im OpenGL-Programm angegebenen Texturkoordinaten weiter. ''Dies ist aber unbedingt nötig!'' Ohne die letzte Zeile hätten wir im Fragment Shader keine gültigen Texturkoordinaten auf TMU0, was in einer Fehldarstellung enden würde.

''im Fragment Shader'' :
<source lang="glsl">
uniform sampler2D texSampler;

void main(void)
{
gl_FragColor = texture2D(texSampler, vec2(gl_TexCoord[0]));
}
</source>
Zuerst deklarieren wir hier einen 2D-Texturensampler, wichtig : '''Texturensampler müssen IMMER als uniform deklariert werden!''' In der Hauptfunktion weisen wir dann einfach den über die Funktion texture2D aus unserer gebundenen Textur ausgelesenen Farbwert, anhand der vom Vertex Shader übergebenen Texturkoordinaten, zu.
{{Vorlage:Hinweis|Der Uniform-Integer für den Sampler referenziert '''nicht''' den Namen (die ID) des Texturobjektes, sondern die Nummer der Texturunit.}}

===Beispiel B===
Zwei Texturen, jeweils auf TMU0 und TMU1. Fragmentfarbe soll eine Multiplikation der beiden Texturen darstellen.

In diesem Beispielfall (der recht häufig vorkommt) müssen wir im Programm festlegen, ''welcher Sampler welche Textureinheit adressiert'', genau deshalb müssen die Texturensampler auch als uniform deklariert werden. Die Standardtextureneinheit eines Samplers ist TMU0, was in unserem Falle natürlich nicht brauchbar ist. Also müssen wir unserem zweiten Textursampler im Programm mitteilen das er seine Daten aus TMU1 beziehen soll :

glUniform1iARB(glSlang_GetUniLoc(ProgramObject, 'texSamplerTMU1'), 1);

Dies ist also unbedingt zu machen, sobald ein Texturensampler eine Textureinheit > GL_TEXTURE_0 adressieren will. Die Textureneinheit des Samplers lässt sich also nicht im Shader selbst festlegen. Der Fragment Shader ist nun allerdings schnell hergeleitet (Vertex Shader verändert sich nicht, da TMU1 die Texturkoordinaten auch von TMU0 bezieht) :

im Fragment Shader :
<source lang="glsl">
uniform sampler2D texSamplerTMU0;
uniform sampler2D texSamplerTMU1;

void main(void)
{
gl_FragColor = texture2D(texSamplerTMU0, vec2(gl_TexCoord[0])) *
texture2D(texSamplerTMU1, vec2(gl_TexCoord[0]));
}
</source>

==Noisefunktionen==
Sowohl im Vertex als auch im Fragment Shader lassen sich [[GLSL noise|Noisefunktionen]] nutzen, mit deren Hilfe sich eine gewisse "Zufälligkeit" simulieren lässt (wirklich zufällige Werte sind es natürlich nicht). Ein zurückgegebener Wert liegt dabei immer im Bereich [-1..1] und ist immer bei gleichem Eigabewert auch immer gleich. Die Verwendung empfiehlt sich derzeit allerdings eher nicht, da nicht alle aktuellen Treiber die Funktionen unterstützen und eine Noisetextur wahrscheinlich performanter ist.

* float noise1 (genType x)
* vec2 noise2 (genType x)
* vec3 noise3 (genType x)
* vec4 noise4 (genType x)

==Discard==
Eigentlich keine Funktion, sondern eine Abbruchbedingung '''nur im Fragment Shader'''. Das Schlüsselwort {{INLINE_CODE|discard}} verwirft das aktuell bearbeitete Fragment und beendet gleichzeitig den Shader. Es kann z.B. genutzt werden um Alphamasking manuell durchzuführen.
Man sollte dabei jedoch beachten dass ein Großteil der aktuellen Hardware kein "early-out" (frühes Beenden) im Fragmentshader unterstützt. Wenn dort also ein {{INLINE_CODE|discard}} auftaucht, wird trotzdem auch der Code danach ausgeführt und einfach verworfen. Einen Geschwindigkeitsvorteil durch diesen Befehl wird man also erst auf neueren Karten feststellen, die dieses Faeature auch so unterstützen wie es angedacht war.

=Beispielshader=
Wen bis hierhin nicht der Mut verlassen hat, und wer aufmerksam gelesen hat, dürfte jetzt also zumindest in der Lage sein kleinere Shader in glSlang zu schreiben und diese auch im Programm zu nutzen. Ich habe im Themenbereich "glSlang" versucht alle Bereiche der Shadersprache selbst anzusprechen und hoffe das auch brauchbar rübergebracht zu haben. Um oben erlerntes (hoffe ich doch mal) nochmal zu vertiefen werde ich jetzt (wie ich das bereits bei meinem ARB_VP-Tutorial getan habe) einen simplen Beispielshader (Vertex und Fragment Shader) auseinanderpflücken um so u.a. auch die Programmstruktur für alle die in C nicht so bewandert sind zu erörtern.

==Der Vertex Shader==
<source lang="glsl">
uniform vec4 GlobalColor;

void main(void)
{
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
gl_FrontColor = gl_Color * GlobalColor;
gl_TexCoord[0] = gl_MultiTexCoord0;
}
</source>

Wie gesagt recht simpel. Angefangen wird mit der Deklaration einer globalen Uniformvariable namens {{INLINE_CODE|GlobalColor}}. Wie wir uns erinnern gibt der Typenqualifizierer uniform an, das wir den Wert dieser Variable (ein 4-Komponentenvektor, da Farbwerte aus R,G,B und A bestehen) in unserem Programm an den Shader übermitteln.

Danach gehts ohne Umwege direkt in unsere Hauptfunktion, da wir im Vertex Shader keine anderen Funktionen benötigen. Dort berechnen wir zuerst die homogene Position unseres Vertex, die sich aus der eingehenden Vertexposition multipliziert mit der Modelansichtsmatrix ergibt. Wie schonmal gesagt '''muss diesem Wert etwas zugewiesen werden''', da sonst alle darauf aufbauenden Funktionen unvorhersehbare Ergebnisse liefern.
Ausserdem wollen wir die Frontfarbe unseres Vertex jedesmal mit der im Programm übergebenen GlobalColor multiplizieren, so dass wir den Farbwert der gesamten Szene aus unserem Programm heraus manipulieren können. Zu guterletzt geben wir dann noch unsere aus der festen Funktionspipeline erhaltenen Texturkoordinaten auf Textureinheit 0 weiter. Wenn im Fragmentshader Texturkoordinaten verwendet werden, '''muss das getan werden'''.

==Der Fragment Shader==
<source lang="glsl">
uniform sampler2D Texture0;
uniform sampler2D Texture1;
uniform sampler2D Texture2;
uniform sampler2D Texture3;

void main(void)
{
vec2 TexCoord = vec2( gl_TexCoord[0] );
vec4 RGB = texture2D( Texture0, TexCoord );

gl_FragColor = texture2D(Texture1, TexCoord) * RGB.r +
texture2D(Texture2, TexCoord) * RGB.g +
texture2D(Texture3, TexCoord) * RGB.b;
}
</source>

Auch hier passiert nicht wirklich viel Großartiges. Wir deklarieren beim Shaderanfang zuerst vier Texturensampler, da wir insgesamt vier verschiedene Texturen im Shader auslesen wollen, eine Verlaufstextur und drei Oberflächentexturen. Auch hier sei wieder gesagt das man Sampler '''immer als uniform deklarieren muss'''. In der Hauptfunktion deklarieren wir dann einen Farbvektor, der auch direkt einen Farbwert aus Textureinheit 0 zugewiesen bekommt. Auf Textureinheit 0 haben wir ihm Hauptprogramm eine Verlaufstextur gebunden, die angibt wie die drei folgenden Texturen ineinander geblendet werden.
Danach schreiben wir dann den Farbwert des Fragmentes, der '''im Fragment Shader ausgegeben werden muss'''. Der besteht wie einfach zu erkennen aus Farbwert von Textureinheit 1 * Rotwert von Textureinheit 0 + Farbwert von Textureinheit 2 * Grünwert von Textureinheit 0 + Farbwert von Textureinheit 3 * Blauwert von Textureinheit 0. So ist z.B. an Stellen an denen in der Verlaufstextur reines blau liegt nur die dritte Textur sichtbar.

So viel also zu unserem kleinen Beispielshader. Er ist weder besonders toll noch besonders sinnvoll, sollte aber auch eher dazu dienen euch glSlang ein wenig zu veranschaulichen, was mir hoffentlich gelungen ist.

Wenn ihr in den vorangegangenen Kapiteln zumindest ein wenig aufgepasst habt, dann könnt ihr euch vor eurem inneren Auge hoffentlich vortstellen was der Shader macht : Er blendet drei Texturen weich anhand der Verlaufstextur ineinander über. Sowas kann man z.B. für ein Terrain nutzen, um dieses anhand einer Farbtextur zu texturieren. Für alle, die damit Probleme haben hier zwei Bilder die den Shader veranschaulichen. Links die Verlaufstextur, die angibt wo welche Textur wie stark gewichtet wird und rechts dann das Ergebnis :

<div align="center"> [[BILD:GLSL_sample_shader_a.jpg]] [[BILD:GLSL_sample_shader_b.jpg]]</div>

=Post Mortem=
Das wars also, meine "Einführung" in die OpenGL Shader Sprache. Ich hoffe es hat euch nicht gelangweilt und auch die von mir zur Verfügung gestellten Informationen haben euch hoffentlich ausgereicht. Mit der Veröffentlichung dieser Einführung geht übrigens auch die Eröffnung eines Shaderforums hier auf der DGL einher, in der ihr dann also fleissig Fragen zum Thema stellen oder eure Shader präsentieren könnt. In diesem Post Mortem gehe ich jetzt noch kurz auf die Zukunft von glSlang ein und zeige ein paar Screenshots (damit die Augen entspannen können), bevor ihr euch dann selbst in die Shaderwelt stürzen könnt.

=Beispiele=

Anbei ein paar exemplarische Screenshots. Da man mit GLSL aber alle möglichen Effekte berechnen kann (u.a. auch 1:1 die feste Funktionspipeline) ist es hier unmöglich einen Überblick aller möglichen Techniken zu geben.

[[Datei:tut_glsl_eigenershader_01.png]] [[Datei:tut_glsl_eigenershader_02.png]] [[Datei:tut_glsl_eigenershader_03.png]]

Wie im ersten (und dritten) Screenshot zu sehen ist es natürlich auch möglich mehrere Techniken innerhalb einer Szene zu nutzen. Hier sind letztendlich bis auf Hardwarelimitationen keine Grenzen gesetzt.

=Die Zukunft=
Als dieses Tutorial geschrieben wurde, war noch nicht ganz abzusehen dass bzw. ob sich GLSL auch durchsetzen würde. ARB-Shadr und NVidias cG waren damals die Platzhirsche, aber inzwischen werden ARB-Shader nicht mehr genutzt (und auch schon länger nicht mehr weiterentwickelt) und auch NVidia setzt primär auf GLSL. GLSL wird permanent weiterenwtickelt und Hersteller können dank des flexiblen Extensionsystems auch in GLSL eigene Extensions offenlegen um die aktuellsten Features (wie z.b. den Tesselator auf aktuellen ATI-Karten) nutzen zu können. GLSL it als inzwischen auch offizielle die Shadersprache frü OpenGL und wird permanent an die neusten technischen Entwicklungen im Grafikkartenbereich angepasst.

Wer also unter OpenGL etwas mit Shadern machen möchte, kommt an GLSL nicht vorbei!

Also viel Spaß beim Experimentieren und Shaderschreiben! Und nicht vergessen : Wir wollen sehen was ihr so treibt,

Euer
:Sascha Willems

{{TUTORIAL_NAVIGATION|-|[[Tutorial_glsl2]]}}
[[Kategorie:Tutorial|GLSL]]

Benutzer:Lord Horazont/Tutorial Versionskontrolle mit GIT

2012-03-04T11:43:52Z

Lord horazont:

= Versionskontrolle mit git =

Hallo und herzlich willkommen zu meinem dritten Tutorial. Heute soll's um Versionskontrolle gehen und zwar demonstriert anhand von git. Warum überhaupt Versionskontrolle? Warum für Hobbyprojekte? Was ist git? Wie macht man das? – diese und andere Fragen werde ich (hoffentlich) beantworten.

== Theorie der Versionskontrolle ==

Nun, jeder der schon einmal einen Wikiartikel geschrieben hat, hatte schon indirekt Kontakt mit Versionskontrolle. Sowas ist nämlich in jedes MediaWiki eingebaut. Immer, wenn man einen Artikel bearbeitet, wird die vorherige Version erhalten, man kann sie später anschauen oder Änderungen rückgängig machen.

Dies gibts nicht nur für Webseiten wie unser Wiki, sondern, in anderer Form, auch für Projekte. Viele werden schonmal irgendwo SVN oder CVS gehört haben, weniger von GIT oder Mercurial. Diese vier sind vermutlich die populärsten Versionskontrolle-Werkzeuge, die im Moment im Einsatz sind.

== Häufige Probleme… ==

=== Problem 1: Mist gebaut? ===
Der große Vorteil der Versionskontrolle liegt auf der Hand. Habt ihr schonmal selbstsicher angefangen, an einem Feature zu arbeiten, dann festgestellt, dass es irgendwie nicht ganz so gut läuft wie erwartet und zum schluss einen Haufen Konflikte im Code gehabt? Da hilft meist nur noch eins: Rückgängig drücken, und zwar oft. Mist! Das Undo-Limit der IDE ist erreicht, aber nichtmal die Hälfte der Änderungen wurden rückgängig gemacht. Dann hat man noch die Möglichkeit, auf ein Backup zurückzugreifen (falls das überhaupt existiert), oder eben alles von Hand wieder Rückgängig machen.

=== Problem 2: Zusammenarbeit ===
Anderes Szenario: Man hat ein Projekt, was gut läuft und was andere (Programmierer) interessant finden. Sie möchten Beitragen, aber natürlich hat man eher wenig Lust immer Archive mit allen Sourcedateien per Mail oder sonstwas zu verschicken. Auch will man den Leuten nicht unbedingt Schreibzugriff auf den eigenen Rechner geben. Also könnte man immer noch, um das Datenvolumen zu reduzieren, Patches verschicken.

== … und ihre Beseitigung durch Versionskontrolle ==
Aus beiden Szenarien gibt es einen gemeinsamen Ausweg: Versionskontrolle und Repositories solcher müssen her!

Anhand von git sei nun im folgenden gezeigt, wie man die beiden genannten Probleme umgeht. Aber wir wollen von Grund auf anfangen, damit ihr das ganze gleich sofort ausprobieren könnt. Dazu beginnen wir damit, wie man Git verwendet. Es sei vorrausgesetzt, dass ihr mit dem Terminal (oder der git-bash, was nichts weiter als eine Bash mit Git für Windows ist) umgehen könnt. Außerdem sollte Git bzw. die Git-Bash natürlich installiert sein ;).

== Ein Git-Repository anlegen und befüllen ==
Das ist recht einfach. Wir wechseln (mit {{INLINE CODE|cd}}) in das Verzeichnis, wo wir ein Git-Repository anlegen wollen. Das ist im optimalfall leer oder das Wurzelverzeichnis unseres Projektes. Dann initialisieren wir ein git Repo mit:

$ git init

War einfach, oder? Jetzt können wir schauen, was git so sagt (vorrausgesetzt, es sind schon Dateien im Verzeichnis, sonst erstmal ein Projekt oder so reinkopieren):

$ git status

Das sollte eine Ausgabe ähnlich dieser erzeugen:
# On branch master
#
# Initial commit
#
# Untracked files:
# (use "git add <file>..." to include in what will be committed)
#
# <font color="#7f0000">a</font>
# <font color="#7f0000">b</font>
nothing added to commit but untracked files present (use "git add" to track)
Wobei anstatt a und b bei euch vermutlich andere Dateien und Verzeichnisse aufgelistet sind. Diese können wir nun mit:
$ git add file1 file2 …
hinzufügen. Das geht aber auch einfacher:
$ git add directory/* # fügt alle Dateien im Verzeichnis directory hinzu (mit Unterverzeichnissen)
$ git add directory # wie oben
$ git add *.c # fügt alle Dateien, die auf .c enden und im Wurzelverzeichnis liegen hinzu
$ git add directory/*.c # könnt ihr sicher erraten: fügt alle Dateien, die auf *.c enden und in directory liegen hinzu (sollte dort ein Ordner auf .c
enden, wird dieser auch hinzugefügt…)
$ git add -A # fügt *alle* dateien, die es im Ordner finden kann, hinzu. Kann zu viel sein, evtl. mit git rm --cached wieder welche entfernen.
Soweit. Nun haben wir git mitgeteilt, dass wir diese Dateien hinzufügen wollen. Das müssen wir noch ''committen'', sozusagen „amtlich“ machen:
$ git commit -v
Das wird euren bevorzugten Terminal-Editor öffnen und ihr könnt eine Commit-Message eingeben, die später im Log zu diesem „Commit“ auftauchen wird. Ein „Commit“ ist sozusagen ein Satz an Änderungen, der logisch zusammen gehört. Was logisch zusammen gehört, definiert sich daran, was ihr zusammen committed ;). Wenn nichts schief gegangen ist, wird git sowas sagen wie:
[master (root-commit) 050a498] * Bla
0 files changed, 0 insertions(+), 0 deletions(-)
create mode 100644 bla/bakery/bread
create mode 100644 bla/cookie
create mode 100644 bla/keks
create mode 100644 c.c
Ansonsten sollte die Fehlermeldung aufschluss darüber geben, was nicht geklappt hat. Eventuell möchte git, dass ihr ihm sagt, wer ihr seid. Das tut ihr mit den Befehlen, die es euch da vorschlägt. Diese Informationen werden in die Commits mit eingebunden, damit man diese den Entwicklern zuordnen kann.

== Änderungen durchführen und committen ==
Nun können wir an unserem Code rumschreiben. Wenn wir einen Schritt weiter zu unserem Ziel gekommen sind, können wir die Änderungen ins Repo committen. Ich mache das meist, wenn ich kompilierfähigen Code habe oder wenn ich einen größeren Schritt erledigt habe oder wenn ich von einer logischen Einheit des Codes in eine andere wechsle (z.B. unterschiedliche Packages oder Module). Jetzt können wir entweder alle Dateien, die wir geändert oder neu hinzugefügt haben mit
$ git add path/to/file.pp path/to/file2.pp
“stagen”, d.h. für den Commit vorsehen, oder wir nutzen
$ git commit -av
wobei das “a” in der Kommandozeile sagt, dass es automatisch alle geänderten Dateien mit in den Commit aufnehmen soll. Beachtet aber, dass es neu erstellte Dateien nicht als “changed” sondern als “untracked” sieht, also werden sie nicht beachtet. Neu erstellte Dateien muss man explizit mit
$ git add path/to/new/file.pp
ankündigen. Das kann man aber ohne Probleme zusammen mit {{INLINE CODE|git commit -av}} benutzen, sodass man nur die neu erstellten Dateien mit {{INLINE CODE|git add}} stage't, aber die anderen mit {{INLINE CODE|git commit -av}}.

$ git log
sollte nun schon ein paar schöne Commits ausgeben.

== Pushs, Fetchs, Merges, Pulls und Branches ==
Ähhh. Was? Ok, der Reihe nach.

Was wir bisher haben ist eigentlich nichts weiter als eine History von Dateiversionen. Das ist schonmal sehr schön, wenn mal was abbrennt (man also einen kritischen Fehler beim Entwickeln gemacht hat und zu einem alten Stand zurückkehren möchte), aber das ist bei weitem nicht alles, was man in moderner Versionskontrolle hat (und zu schätzen lernen wird).

Zunächst ist git ein sogenanntes DVCS, ein ''Distributed Version Control System''. Das Distributed lässt erahnen, dass wir Daten auch auf anderen Rechnern haben können. Wer einen eigenen Server hat (sei es nun zu Hause oder im Internet), der kann mit [http://sitaramc.github.com/gitolite/ gitolite] ganz einfach einen sicheren git Repository Server aufsetzen. Für Public Access findet man auch schnell was im Internet.

Der Vorteil liegt auf der Hand: Die Daten liegen nicht mehr nur auf einem Rechner. Wenn da also mal die Festplatte abraucht oder der Blitz einschlägt – der Code ist sicher (ausreichende Push-Frequenz vorrausgesetzt). Man hat die Daten sogar Unterwegs zur Verfügung.

Ich möchte jetzt nicht genau darauf eingehen, wie man mit gitolite einen Repository-Server aufsetzt, sondern lieber ein bisschen die Bedienung von git erläutern und ein paar Beispiele durchgehen.

=== Branches ===
Wer noch nicht viel mit Versionskontrolle zu tun hat, dem sei das Konzept von Branches ans Herz gelegt.

=== Clones, Fetches und Pulls ===
Wenn man an einem mit git verwalteten Projekt mitmachen möchte, wird man häufig auf so eine Kommandozeile stoßen:
$ git clone https://...
Das ist der Befehl, um ein Git-Repository zu klonen, wobei die Quelle als ''remote'' names ''origin'' eingetragen wird. Das ist so git Tradition und sollte nicht unbedingt gebrochen werden (kann aber ohne weiteres).

Ein ''remote'' ist erstmal nicht viel mehr als ein Eintrag in Git's „Datenbank“, wo es Commits herbekommen kann und welche ''branches'' dort existieren.

== “A successful git branching model” ==
Auf [http://nvie.com/posts/a-successful-git-branching-model/ dieser Seite] bin ich auf ein sehr hilfreiches Arbeitsmodell für das Arbeiten mit Branches unter Git gestoßen. Das könnt ihr euch am besten Ausdrucken und an die Wand pinnen.

Benutzer:Lord Horazont

2012-03-04T11:33:53Z

Lord horazont: /* Working drafts */ Zu blöd zum tippen der gute ....

Also grundsätzlich werde ich nicht beständig am Wiki arbeiten, sondern immer dann, wenn ich einen Befehl, beispielsweise die SDLNET-Befehle verwende und hier keine Dokumentation finde. Dann werde ich wohl diese wohl auch übersetzen.

So langsam beginne ich auch, Tutorials zu schreiben. Das ist vorallem während größeren Projekten so, wenn ich selber viele Techniken implementiere und lerne. Das Wissen gebe ich gerne an die Community weiter.

== Tutorials von mir ==
* [[Tutorial_SDL_RWops|Tutorial SDL_RWops]]
* [[Tutorial_Wassereffekt|Tutorial Wassereffekt]]

== Working drafts ==
* [[Benutzer:Lord_Horazont/Tutorial_Versionskontrolle_mit_GIT|Tutorial: Versionskontrolle mit git]]

== "Normale" Artikel von mir ==
Einfach unter "werkzeuge" auf Benutzerbeiträge klicken, für die wohl eher wenigen, die es interessiert ;)

Benutzer:Lord Horazont

2012-03-04T11:33:31Z

Lord horazont:

Also grundsätzlich werde ich nicht beständig am Wiki arbeiten, sondern immer dann, wenn ich einen Befehl, beispielsweise die SDLNET-Befehle verwende und hier keine Dokumentation finde. Dann werde ich wohl diese wohl auch übersetzen.

So langsam beginne ich auch, Tutorials zu schreiben. Das ist vorallem während größeren Projekten so, wenn ich selber viele Techniken implementiere und lerne. Das Wissen gebe ich gerne an die Community weiter.

== Tutorials von mir ==
* [[Tutorial_SDL_RWops|Tutorial SDL_RWops]]
* [[Tutorial_Wassereffekt|Tutorial Wassereffekt]]

== Working drafts ==
* [[Benutzer:Lord_Horazont/Tutorial_Versionskontrolle_mit_GIT Tutorial: Versionskontrolle mit git]]

== "Normale" Artikel von mir ==
Einfach unter "werkzeuge" auf Benutzerbeiträge klicken, für die wohl eher wenigen, die es interessiert ;)

Checkliste Shader

2012-03-01T09:37:07Z

Lord horazont:

==Verwendung der Checkliste==
Die nachfolgende Checkliste sollte nach und nach abgearbeitet werden um einfache Fehler auszuschließen.
Wenn ein Punkt mit ja beantwortet werden kann, kann man den nächsten Punkt angehen.

Die Grundlagen sollen ausschließen, dass Fehler existieren noch bevor der Shader ins Spiel kommt.

==Grundlagen==
*'''Benutze ich eine funktionierende Programmgrundlage (Template)?'''
:Wurde ein [[Template]] von DelphiGL.com benutzt, oder wurde das Template bereits erfolgreich getestet dann kann von einer Funktionierenden Programmgrundlage ausgegangen werden.

*'''Funktioniert das Programm ohne Shader?'''
:Kommentiere allen Shader Code aus, bzw. umgehe den Shadercode falls möglich und prüfe die Ausgabe um sicherzustellen, dass nicht andere Teile der Ausgabe den Fehler verursachen (z.B. Z-Buffer, Blending etc.)

*'''Läuft das Programm ohne OpenGL-Fehler zu produzieren?'''
:Benutzen sie einen Error-Handler wie er im "[[Tutorial_quickstart]]" beschrieben wird, um dies zu testen.

*'''Unterstützt die Grafikkarte überhaupt Shader?'''
:Fragen Sie die OpenGL Version ab. Es wird mindestens OpenGL Version 2.0 oder 1.5 mit den Extensions, die [http://wiki.delphigl.com/index.php/Tutorial_glsl#Voraussetzungen hier] aufgelistet sind, benötigt. Siehe [[glGetString]]

==Problemspezifisches==
*'''Funktioniert die Fehlerabfrage beim Shaderbau?'''
:Bauen Sie versuchsweise etwas in den Shader ein, was Compilefehler verursachen muss und prüfen sie ob die Meldung entsprechend geloggt wird.

*'''Läßt sich der Shader kompilieren?'''
:Prüfen Sie, ob der Code wirklich korrekt an [[glShaderSource]]() übergeben wird (einfach einen Haltepunkt setzen).

*'''Wurden die Uniforms erst gesetzt als der Shader gebunden war?'''
:Ein ''beliebter'' Fehler: Stellen Sie sicher dass Uniforms erst gesetzt werden nachdem der Shader gebunden war.

*'''Werden Vektortransformationen korrekt durchgeführt?'''
:Will man einen vec3-Vektor mithilfe einer mat4-Matrix transformieren, so muss man ihn erst in einen vec4 umwandeln. Dabei sollte die w-Komponente den Wert 1.0 bekommen (Imitation von [[glVertex3f]]).

*'''Wird der Fragmentshader überhaupt ausgeführt?'''
:Den Fragmentshader einfach mal eine konstante Farbe (ungleich der Hintergrundfarbe) ausgeben lassen um zu sehen ob dieser überhaupt ausgeführt wird.

*'''Entspricht die Ausgabe nicht den erwarteten Beleuchtungsergebnissen?'''
:Checken ob die Normalen richtig sind. Dazu einfach im Fragmentshader die Normale als Farbe ausgeben. Die Farbe sollte sich je nach Ausrichtung einer Fläche zur Kamera ändern. Zur Kamera gewandte Flächen sollten bläulich erscheinen, da die Normale in Richtung der Z-Achse stehen müsste. Es ist oft einen Versuch Wert einfach mal das Vorzeichen der Normale umzukehren. Damit die Farben gut rauskommen kann dieser Codeschnipsel verwendet werden:
gl_FragColor = vec4(normal / 2.0 + 0.5, 1.0);

=== Texturierung ===
*'''Entspricht die Texturierung nicht den Erwartungen?'''
:Checken ob die Texturkoordinaten korrekt sind. Auch hier die Texturkoordinaten als Farbwert ausgeben lassen.

*'''Texturkoordinaten stimmen, trotzdem ist die Ausgabe nicht korrekt?''' / '''Texturen werden weiß'''
:Die Uniform-Integer der Sampler für die Texturen müssen auf die ''Texturunit'' und nicht auf die ID des Texturobjektes gesetzt werden.

Checkliste Texturierung

2012-02-11T20:59:26Z

Lord horazont: /* Problemspezifisches */ Texturfilter erwähnt

==Verwendung der Checkliste==
Die nachfolgende Checkliste sollte nach und nach abgearbeitet werden um einfache Fehler auszuschließen.
Wenn ein Punkt mit ja beantwortet werden kann, kann man den nächsten Punkt angehen.

==Grundlagen==
*'''Benutze ich eine funktionierende Programmgrundlage (Template)?'''
:Wurde ein [[Template]] von DelphiGL.com benutzt, oder wurde das Template bereits erfolgreich getestet dann kann von einer Funktionierenden Programmgrundlage ausgegangen werden.

*'''Funktioniert das Programm ohne Texturierung?'''
:Kommentieren Sie allen Texturierungsrelevanten Code aus, und prüfen Sie die Ausgabe.

*'''Läuft das Programm ohne OpenGL-Fehler zu produzieren?'''
:Benutzen Sie einen Error-Handler wie er im "[[Tutorial_quickstart]]" beschrieben wird, um dies zu testen.

*'''Tritt der Fehler bei der Benutzung eines speziellen Texturloaders auf?'''
:Lesen Sie die Dokumentation zu dem von ihnen favorisierten Texturloader. z.B: [[Glbitmap_loader|glBitmap.pas]]

==Problemspezifisches==
*'''Haben Sie die Texturierung für das entsprechende Objekt aktiviert?'''
:Falls alle Objekte mit Texturen gezeichnet werden sollen, reicht es beim Setup von OpenGL per [[glEnable]](GL_TEXTURE_2D) Texturierung zu aktivieren.
:Falls nur einzelne Objekte texturiert werden sollen, muss vor diesem Objekt Texturing aktiviert, und vor den texturlosen Objekten Texturing wieder deaktiviert (glDisable(GL_TEXTURE_2D)) werden.

*'''Haben Sie Texturcoordinaten für die zu texturierenden Objekte festegelegt?'''
:Texturcoordinaten werden mit [[glTexCoord]] spezifiziert.

*'''Haben Sie die Textur gebunden?'''
:Der Befehl zum binden von Texturen lautet [[glBindTexture]]. Hierzu gehört natürlich auch, dass die Textur geladen wurde. Dazu benutzt man üblicherweise einen Texturloader. Einige Loader (z.B. [[Glbitmap_loader|glBitmap.pas]]) besitzen eine Funktion namens "bind" welche nach dem Laden das Binden für sie übernimmt.

*'''Sind die Filter der Textur richtig gesetzt?'''
:Wenn keine [[Mipmap|Mipmaps]] generiert wurden, bekommt man ohne explizite Filterangabe mittels [[glTexParameteri]] nur eine weiße Ausgabe. Daher die Filter auf nicht-Mipmap-Werte setzen oder Mipmaps, z.B. mit '''GL_GENERATE_MIPMAPS''' erzeugen.

*'''Ist die Textur in einem gültigen Format?'''
:Texturen müssen im sogenannten "2^n Format" sein. Das heißt das die Seitenlänge der Textur (in Pixel) eine Potenz von 2 sein muss (z.B. 32x32, 64x256, 1024x512). Nur Karten die offiziell den OpenGL2.0 Standard unterstützen können auch andere Formate benutze (z.B. 1024x768, 112x232). (Bei falschen Texturgrößen wird das Objekt sonst einfach farbig und untexturiert gerendert.)
:Um zu Prüfen welchen Standard ihre Grafikkarte unterstützt lesen sie den Artikel zu [[glGetString]]

==Multitexturing==
*'''Unterstützt die Zielgrafikkarte Multitexturing?'''
:Im Tutorial [[Tutorial_MultiTexturing#Schritt_1_-_Hardware_auf_Multitexturing-F.C3.A4higkeit_pr.C3.BCfen|Multitexturing]] wird erklärt, wie man checkt, ob Multitexturing von Grafikkarte und Treiber unterstützt wird.

Timebased Movement

2012-01-23T17:52:52Z

Lord horazont: /* Berechnung der vergangen Zeit */ Erläuterung für Frequenz

== Kurz-Beschreibung ==
'''Timebased Movement''' sorgt dafür, dass die Bewegungsgeschwindigkeiten nicht vom CPU-/Renderspeed abhängen.

== Prinzip ==
Nehmen wir an wir möchten einen Ball darstellen der sich mit konstanter Geschwindigkeit vom linken Bildschirmrand zum rechten Bildschirmrand bewegt.

Das erste Bild wird den Ball ganz links zeigen. Auf dem nächsten Bild wird der Ball ein Stück weiter sein, die Frage ist nur wie weit? Die Länge der Strecke die der Ball zurücklegen muss legen wir nun mal willkürlich auf 1 Längeneinheit (kurz: LE) fest. Die Strecke soll er in 5 Sekunden zurück legen.

Ein Rechner A braucht 1 Sekunde um 1 Bild zu Berechnen. Um das gewünschte Ergebnis zu erreichen müssten wir den Ball nach jedem Bild 0.2 Felder weiterbewegen.

In einer Sekunde hätten wir also folgende Bilder:
* Bild 0: Ball Position: 0.0
* Bild 1: Ball Position: 0.2 (weiterbewegt um 0.2 LE in 1.0 Sekunden)
* Bild 2: Ball Position: 0.4 (weiterbewegt um 0.2 LE in 1.0 Sekunden)
* Bild 3: Ball Position: 0.6 (weiterbewegt um 0.2 LE in 1.0 Sekunden)
* Bild 4: Ball Position: 0.8 (weiterbewegt um 0.2 LE in 1.0 Sekunden)
* Bild 5: Ball Position: 1.0 (weiterbewegt um 0.2 LE in 1.0 Sekunden)

Ein Rechner B braucht nur 0.5 Sekunden um ein Bild zu berechnen.

Ebenfalls in nur einer Sekunde hätten wir folgende Bilder:
* Bild 0: Ball Position: 0.0
* Bild 1: Ball Position: 0.1 (weiterbewegt um: 0.1 LE in 0.5 Sekunden)
* Bild 2: Ball Position: 0.2 (weiterbewegt um: 0.1 LE in 0.5 Sekunden)
* Bild 3: Ball Position: 0.3 (weiterbewegt um: 0.1 LE in 0.5 Sekunden)
* Bild 4: Ball Position: 0.4 (weiterbewegt um: 0.1 LE in 0.5 Sekunden)
* Bild 5: Ball Position: 0.5 (weiterbewegt um: 0.1 LE in 0.5 Sekunden)
* Bild 6: Ball Position: 0.6 (weiterbewegt um: 0.1 LE in 0.5 Sekunden)
* Bild 7: Ball Position: 0.7 (weiterbewegt um: 0.1 LE in 0.5 Sekunden)
* Bild 8: Ball Position: 0.8 (weiterbewegt um: 0.1 LE in 0.5 Sekunden)
* Bild 9: Ball Position: 0.9 (weiterbewegt um: 0.1 LE in 0.5 Sekunden)
* Bild 10: Ball Position: 1.0 (weiterbewegt um: 0.1 LE in 0.5 Sekunden)

Bei dem einen Rechner muss der Ball bei jedem Bild um 0.2 LE bewegt werden, beim andern Rechner nur 0.1 LE pro Bild. Tut man dies nicht, bewegt sich der Ball zu schnell oder zu langsam.

Doch woher weiß man nun wie weit man seinen Ball auf den jeweiligen Rechner pro Bild bewegen muss?

In unserem Beispiel bewegt sich der Ball mit der konstanten Geschwindigkeit von 0.2 LE pro Sekunde. Mit folgender Formel können wir bei konstanter Geschwindigkeit die neue Position berechnen:

neue_Position = Geschwindigkeit * vergangene_Zeit + alte_Position

Wir brauchen also nur eine Geschwindigkeit festlegen und messen, wie viel Zeit vergangen ist, um die neue Position zu berechnen zu können.

Wohlgemerkt gilt diese Formel nur wenn sich das Objekt mit konstanter Geschwindigkeit fortbewegt.

== Berechnung der vergangen Zeit ==

Allgemein:
VergangeneZeit := ( Zeit1 - Zeit0 ) / Frequenz;

Die Frequenz ist hierbei die Timerticks pro Sekunde. Damit ist sie (bei einem 1ms-Timer) gleich dem Umrechnungsfaktor von Sekunden zu Millisekunden, also 1000.

=== Millisekunden genau unter Windows===
Die wohl einfachste aber auch ungenaueste Möglichkeit unter Windows so etwas zu realisieren besteht darin mit Hilfe von GetTickCount die Zeit (in Millisekunden) seit dem letzen Windows-Start zu ermitteln.

<source lang="pascal">
//Benötigte Variablen
var
BerechnungsZeit : LongWord;
Position : Double;

procedure BeimStart; // Was hier drinnen steht sollte zum Start ausgeführt werden
begin
BerechnungsZeit := GetTickCount();
end;

procedure BerechnungsCheck; // Alle nötigen Berechnungen durchführen
const
Frequenz = 1000; // Durch Windows festgelegt
var
AktuelleZeit : LongWord;
begin
AktuelleZeit := GetTickCount();
Berechne((AktuelleZeit - BerechnungsZeit) / Frequenz);
BerechnungsZeit := AktuelleZeit;
end;

procedure Berechne(vergangene_Zeit : Double);
const
Geschwindigkeit = 0.5;
begin
{Alle Berechnungen stehen hier }
// z.B.
Position := Geschwindigkeit * vergangene_Zeit + Position;
end;
</source>

=== Absolute Genauigkeit per Hardware ===
Man kann auch die Hardware zur Zeitmessung nutzen um so noch genauere Ergebnisse zu erzielen. Es kann jedoch theoretisch sein, dass diese nicht zur Verfügung steht. Zudem handelt es sich hierbei um reine Windows API-Aufrufe. Bei Verwendung von FreePascal bzw. Lazarus sollte diese Methode also nicht in betracht gezogen werden.

<source lang="pascal">
//Benötigte Variablen
var
BerechnungsZeit : Int64;
Frequenz : Int64;
Position : Double;

procedure BeimStart; // Was hier drinnen steht sollte zum Start ausgeführt werden
begin
if not QueryPerformanceFrequency(Frequenz) then // Frequenz ermitteln
raise Exception.create('Kein Hardware Timer vorhanden');
QueryPerformanceCounter(BerechnungsZeit); // Aktuelle Zeit ermitteln
end;

procedure BerechnungsCheck; // Alle nötigen Berechnungen durchführen
var
AktuelleZeit : Int64;
begin
QueryPerformanceCounter(AktuelleZeit);
Berechne((AktuelleZeit - BerechnungsZeit) / Frequenz);
BerechnungsZeit := AktuelleZeit;
end;

procedure Berechne(vergangene_Zeit : Double);
const
Geschwindigkeit = 0.5;
begin
{Alle Berechnungen stehen hier }
// z.B.
Position := Geschwindigkeit * vergangene_Zeit + Position;
end;
</source>

Man hat nun den Geschwindigkeitsfaktor, den man mit sämtlichen Bewegungen multipliziert. Wenn der PC viele Frames per Second rendert wird der Geschwindigkeitsfaktor klein. Die Bewegungen werden dadurch naturlich auch kleiner. Je niedriger die Ausführungsgeschwindigkeit der Zeichenprozedur, desto höher wird der Geschwindigkeitsfaktor, die Bewegungsschritte also auch größer.

== Konstant Beschleunigte Bewegung ==

Nehmen wir an wir möchten darstellen wie ein Ball zu Boden fällt. Der Ball sei 1 LE über dem Boden und wird dort zum Zeitpunkt 0s losgelassen. Die Kraft welche die Erdanziehung simuliert soll pro Sekunde die Geschwindigkeit des Balles um 1 LE/s erhöhen.

Die neue Geschwindigkeit die sich durch die Beschleunigung ergeben hat, läßt sich noch sehr einfach Berechnen:
neue_Geschwindigkeit := Beschleunigung * vergangene_Zeit + alte_Geschwindigkeit;

Wie sieht es aber mit der Position aus?

Falsch wäre diese Berechnung:
neue_Position := alte_Geschwindigkeit * vergangene_Zeit + alte_Position
Denn so würde sich der Ball von Bild 0 nach Bild 1 gar nicht bewegen.

Genauso falsch wäre diese Berechnung:
neue_Position := neue_Geschwindigkeit * vergangene_Zeit + alte_Position

Denn dann würde sich der Ball sofort mit der vollen Geschwindigkeit bewegen und wäre viel zu schnell ab Boden.

Wer sich ein wenig mit Physik auskennt weiß das man bei konstant Beschleunigter Bewegung so die neue Position ausrechnet:
neue_Position := 0.5 * Beschleunigung * vergangene_Zeit * vergangene_Zeit + Geschwindigkeit * vergangene_Zeit + alte_Position

Beispielcode:
<source lang="pascal">
var
Position : Double;
Geschwindigkeit : Double;
procedure Berechne(vergangene_Zeit : Double);
const
Beschleunigung = 1;
begin
Position := 0.5*Beschleunigung * vergangene_Zeit * vergangene_Zeit + Geschwindigkeit * vergangene_Zeit + Position
// Wichtig: alte Geschwindigkeit erst ändern wenn sie nicht mehr gebraucht wird.
Geschwindigkeit := Beschleunigung * vergangene_Zeit + Geschwindigkeit
end;
</source>

== Umsetzung mit einer Delphi Form ==
<source lang="pascal">
var
[...]
Frequency, StartCount, EndCount: Int64;
Speedfactor: Extended;

const
Scalefactor = 100; //Der Scalefactor ist ein beliebiger Wert um den Speedfactor
//zu beeinflussen
[...]
procedure TForm1.FormCreate(Sender: TObject);
begin
if not QueryPerformanceFrequency(Frequency) then
raise Exception.create('Kein Hardware Timer vorhanden');
QueryPerformanceFrequency(Frequency); //Frequenz des Rechners ermitteln
[...]
end;

procedure TForm1.IdleHandler(Sender: TObject; var Done: Boolean);
begin
QueryPerformanceCounter(StartCount); //Zeit0
Form1.Render;
QueryPerformanceCounter(EndCount); //Zeit1
Speedfactor := ((EndCount - StartCount) /Frequency) * Scalefactor //(Zeit1 - Zeit0) / Frequenz
[...]
end;
</source>

Man hat nun den Speedfactor, den man mit sämtlichen Bewegungen multipliziert. Und schon hat man eine einfache Umsetzung von Timebased movement, ohne sich über Physik Gedanken machen zu müssen.

== Links ==
*[[Tutorial_Bomberman2#Timebased_Movement]]
*[[SDL_GetTicks]] - Methode zur Zeitmessung mit SDL

Link

2012-01-02T13:15:08Z

Lord horazont: /* Texturen / 2D-Grafiken */ Neue Sektion „Sonstige 2D-Grafiken“ mit famfamfam silk Iconset

Diese Linksammlung soll allgemeine Links zu unterschiedlichen Themen bieten, die mit der Multimediaentwicklung zu tun haben.
{{Hinweis|Vielleicht ist eine Zusammenführung mit [[Tool]] sinnvoll!}}
{{Hinweis|Vielleicht ist eine Aufteilung in Unterseiten sinnvoll (möglicherweise mit Kategorien)}}

= Entwicklung mit OpenGL =

== Hardwareinfos ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://web.archive.org/web/20090417044334/http://delphi3d.net/hardware/listreports.php OpenGL Hardware Registry - Hardwareübersicht]
|{{Englisch}}
|Eine Datenbank aller Grafikkarten die in der Harware Registry vorhanden sind. Die einzelnen Artikel enthalten Infos darüber, welche Extensions von der Grafikkarte unterstützt werden.
|-
|[http://web.archive.org/web/20090506094005/http://delphi3d.net/hardware/ OpenGL Hardware Registry - Extensionübersicht]
|{{Englisch}}
|Eine Datenbank aller Extensions die in der Harware Registry vorhanden sind. Die einzelnen Artikel enthalten Infos darüber, welche Grafikkarten die entsprechende Extension unterstützen.
|-
|}


== Tutorials ==

{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
||[[Tutorial|DGL Wiki - Tutorial]]
|{{Deutsch}}
|DelphiGL.com ist Betreiber dieses Wikis und stellt eine Vielzahl Tutorials mit Schwehrpunkt OpenGL zur Verfügung.
Neben Tutorials für Einsteiger und OpenGL Anfänger gibt es auch fortgeschrittene Themen wie Shader oder Partikelsysteme.Sprache der Wahl ist hier Delphi.
|-
|[http://www.joachimrohde.com/cms/xoops/modules/articles/index.php?cat_id=1 joachimrohde.com]
|{{Deutsch}}
|Auf dieser Seite findet ihr deutsche Übersetzungen der bekannten NeHe Tutorials. Sprache der Wahl ist hier C++.
|-
|[http://www.cg.tuwien.ac.at/studentwork/VRSem96/OpenGL/ Technische Universität Wien]
|{{Deutsch}}
|Diese Seite bietet einen allgemeinen Überblick über die primären Funktionen von OpenGL und richtet sich vor allem an Einsteiger.
|-
|[http://nehe.gamedev.net/ Nehe]
|{{Englisch}}
|Die berühmt berüchtigten NeHe Tutorials sind eine umfangreiche Sammlung an Tutorials zum Thema OpenGL. Von Anfängertutorials bis hin zu komplexen Effekten wird alles behandelt. Sprache der Wahl ist hier C++. (Eine Übersetzung der NeHe Tutorials findet ihr bei Joachim Rhode (siehe oben). )
|-
|[http://www.sulaco.co.za/tut.htm sulaco.co.za]
|{{Englisch}}
| OpenGL Beispiele in Delphi
|}

== OpenGL Funktionen ==

=== GL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GL|DGL Wiki - Kategorie GL]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten OpenGL Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL.tar.gz OpenGL.org - Orginal Spezifkationen]
|{{Englisch}}
|Die Orginalspezifikationen der OpenGL 1.0 und OpenGL 1.1 Befehle. (Diese HTML-Dokumente sind nicht Copy&Paste freundlich, da sie vermutlich automatisch aus vorhandenen Dateien (Postscript) erzeugt wurden.)
|-
|[http://developer.3dlabs.com/documents/glmanpage_index.htm 3dLabs]
|{{Englisch}}
|Die Orginalspezifikationen der OpenGL 1.0 und OpenGL 1.1 Befehle.
|-
|[http://web.archive.org/web/20040616082839/http://www.mevis.de/~uwe/opengl/opengl.html mevis.de]
|{{Englisch}}
|Sammlung von Englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|[http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/glfunc01_4f03.asp MSDN von Microsoft]
|{{Englisch}}
|OpenGL Dokumentation in der MSDN. Die Erklärung der MSDN sind meist keine reinen Kopien der Orginalspezifikationen, sondern enthalten hin und wieder auch zusätzliche Informationen, oder formulieren Texte auf verständlichere Art und Weise.
|-
|}

=== GLU ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GLU|DGL Wiki - Kategorie GLU]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten GLU Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/glu/ OpenGL.org - Orginal Spezifkationen]
|{{Englisch}}
|Orginalspezifikationen für die GLU Befehle. (Diese HTML-Dokumente sind nicht Copy&Paste freundlich, da sie vermutlich automatisch aus vorhandenen Dateien (Postscript) erzeugt wurden.)
|-
|[http://web.archive.org/web/20040616082839/http://www.mevis.de/~uwe/opengl/opengl.html mevis.de mevis.de]
|{{Englisch}}
|Sammlung von englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|[http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/glufnc01_0e43.asp MSDN von Microsoft]
|{{Englisch}}
|GLU Dokumentation in der MSDN. Die Erklärung der MSDN sind meist keine reinen Kopien der Orginalspezifikationen, sondern enthalten hin und wieder auch zusätzliche Informationen, oder formulieren Texte auf verständlichere Art und Weise.
|-
|}

=== GLX ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GLX|DGL Wiki - Kategorie GLX]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten GLX Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/glx/ OpenGL.org - Orginal Spezifkationen]
|{{Englisch}}
|Orgninalspezifikationen der GLX Befehle bei OpenGL.org.
|-
|[http://web.archive.org/web/20040616082839/http://www.mevis.de/~uwe/opengl/opengl.html mevis.de mevis.de]
|{{Englisch}}
|Sammlung von Englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|}

=== WGL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:WGL|DGL Wiki - Kategorie WGL]]
|{{Deutsch}}
|Wiki-Kategorie die alle übersetzten WGL Befehle enthält.
|-
|[http://web.archive.org/web/20071218151417/http://developer.3dlabs.com/documents/wglmanpage_index.htm 3dLabs]
|{{Englisch}}
|Sammlung einiger WGL Befehlsspezifikationen.
|-
|}

=== GLUT ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://freeglut.sourceforge.net/docs/api.php The freeglut Projekt]
|{{Englisch}}
|Englischsprachige Dokumentation zum OpenGL Utility Toolkit kurz GLUT.
|-
|}

=== SDL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:SDL|DGL Wiki - Kategorie SDL]]
|{{Deutsch}}
|Übersicht aller auf die SDL bezogenen Artikel hier im Wiki. Darunter befinden sich eine Vielzahl von Übersetzungen der SDL Befehlspezifikationen. Diese können auch in der [[SDL-Funktionsübersicht]] gefunden werden.
|-
|[http://www.libsdl.org/cgi/docwiki.cgi/SDL_20API libsdl.org]
|{{Englisch}}
|Das Dokumentationswiki von libSDL.org enthält die komplette Dokumenation zur SDL in englischer Sprache.
|-
|-
|[http://www.freepascal-meets-sdl.net/ freepascal meets sdl]
|{{Englisch}}
| Eine Webseite die speziell Informationen über die Programmierung von SDL unter Freepascal zur Verfügung stellt.
|-
|}

== FAQs ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[FAQ| DGL Wiki - FAQ]]
|{{Deutsch}}
|Ein FAQ (Frequently Asked Questions = Häufig gestellte Fragen) zu DelphiGL.com und dem DGL Wiki.
|-
|[http://www.3dsource.de/faq/index.htm 3dsource.de]
|{{Deutsch}}
|Ein FAQ zu Fragen rund um OpenGL.
|-
|}

== Effekte und Techniken mit OpenGL ==

===Glow===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamasutra.com/view/feature/2107/realtime_glow.php Gamasutra]
|{{Englisch}}
|Beschreibt, wie man mit Hilfe von Shader(hier DirectX Shader) den Gloweffekt in Realtime umsetzt. Dabei wird erst die Technik dahinter erklährt, und dann wie man sie Schritt für Schritt umsetzt.
|-
|[http://web.archive.org/web/20071118043007/http://collective.valve-erc.com/index.php?go=tron1 valve-erc.com]
|{{Englisch}}
|Schritt für Schritt Anleitung, wie man mit Hilfe von Cg in OpenGL den Glow Effekt realisieren kann
|-
|}

===HDR===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://web.archive.org/web/20090601052809/http://www.gamedev.net/columns/hardcore/hdrrendering/ gamedev.net]
|{{Englisch}}
|Hier wird sehr kurz eingeleitet, was HDR Rendering überhaupt ist, dann wird der Aufbau des *.hdr Formats erläutert, und dann geht es schon von 0 auf 100 zum Programmieren. Erklährungen gibt es kaum, dafür werden fertige Shader(für DirectX) geboten.
|-
|[http://web.archive.org/web/20090601202039/http://www.gamedev.net/reference/articles/article2208.asp gamedev.net]
|{{Englisch}}
|Beschreibt auch nur etwas kurz das HDR Verfahren, jedoch mit mehr mathematischen Hintergrund in Sachen Tonemapping. Beispielcode für Tonemapping in C++ liegt bei.
|-
|}

===BSP Bäume===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://web.archive.org/web/20081201115631/http://www.3dtechdev.com/tutorials/leafbsp/3dbsptrees.html 3dtechdev.com]
|{{Englisch}}
|Das beste Dokument überhaupt, für allem die selber BSP Bäume compilieren möchte. Ist belegt mit sehr viel Grafik. Erst beginnt er das Prinzip allgemein zum umschreiben, dann wird alles genau erläutert, und mit verständlichen Pseudocode untermalt.
|-
|[http://web.archive.org/web/20081019041535/http://www.3dtechdev.com/tutorials/illegalgeometry/illegalgeometrytut.html 3dtechdev.com]
|{{Englisch}}
|Nicht ganz so gut geworden, wie sein erstes Tutorial, aber erklährt auch sehr gut, wie man illegale Geometrie aufspürt und beseitigt. Wieder mit Grafiken und Pseudocodes verständlich belegt. Hiermit kann man seinem Map-Compiler den letzten Schliff verleien.
|-
|[http://www.gamedev.net/reference/articles/article981.asp Gamedev]
|{{Englisch}}
|Von Michael Abrash, dürfte der ''Erfinder'' von Quake sein. Naja, meine Englischkenntnisse reichen hier nicht ganz aus, um den Text zu verstehen. Ist etwas umständlich geschrieben. Dafür mit Grafiken unterlegt.
|-
|[http://www.zfx-online.de/Tutorials.php?ID=11 Part 1 - Allgemein]
|{{Deutsch}}
|Einzigste deutsche Referenz zu BSP Bäumen, dafür Daumen hoch. Ist aber nicht das Wahre: schlechter C Code, und ich hatte auch nicht den Einduck, das er die Theorie zu diesem Thema bis in die Tiefe verstanden hat(oder er wollte es nicht zu akademisch Erklähren oO). Aber ein guter Einstieg in dieses Thema.
|-
|[http://www.zfx-online.de/Tutorials.php?ID=13 Part 2 - Kollision und PVS]
|{{Deutsch}}
|-
|[http://web.archive.org/web/20060516103821/http://www.cs.uwec.edu/~stevende/cs455/programs/GameTutorials%20-%20Quake%203%20BSP%20Format.htm Quake3 *.bsp Format]
|{{Englisch}}
|Die beste Dokumentation für das BSP Format, die ich gefunden habe, besser als den Quake3 Sourcecode zu durchforsten. Leider etwas magere Eklährung zu wichtigen Themen wie Patches(Curved Surfaces). Ich pers. hatte jetzt 1 1/2 Wochen gebraucht, um das *.bsp Format vollständig zu verstehen. Ist aber anscheinend die beste Format Dokumentation im Netz.
|-
|[http://www.flipcode.com/articles/article_q2bsp.shtml Quake2 *.bsp Format]
|{{Englisch}}
|Kann auch nur soviel sagen, wie beim Link zuvor. Es fehlen hier auch zum Teil Informationen. Man muss halt viel ausprobieren, und sich den Quake 2 Source zu Herzen nehmen, damit man es versteht.
|-
|}

===Himmel & Wolken===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamedev.net/community/forums/topic.asp?topic_id=86024 Gamedev]
|{{Englisch}}
|Guter Thread mit vielen Anregungen und Links.
|-
|[http://www.gamedev.net/community/forums/topic.asp?topic_id=135654 Gamedev]
|{{Englisch}}
|Hier wird die Diskussion zum obigen Link weitergeführt.
|-
|[http://freespace.virgin.net/hugo.elias/models/m_clouds.htm Plasma]
|{{Englisch}}
|Eine nette Idee um Plasma in Echtzeit zu generieren, und zu verändern. Leider nichts zum Shading.
|-
|[http://nis-lab.is.s.u-tokyo.ac.jp/~nis/cdrom/sig00_cloud.pdf 3D Wolken]
|{{Englisch}}
|Paper über generieren und rendern von 3 dimensionalen Wolken inklusive Schatten und Lichtstrahlen. Ich hab nur den Lichtstahlen-Algorithmus ausprobiert. Saulangsam aber sehr einfach zu implementieren. Einen Blick ist es auf jeden Fall wert.
|-
|[http://web.archive.org/web/20031011052035/http://www.geocities.com/ngdash/whitepapers/skydomecolor.html Skydome]
|{{Englisch}}
|Wenn man mal schnell gute Farben für seinen Skydome braucht...
|}

===Terrain===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.flipcode.com/articles/article_geomipmaps.shtml FlipCode]
|{{Englisch}}
|Artikel zu Geomipmaping. Zummindest hab ich es hier zum ersten mal gesehen. Und es funzt ganz gut.
|-
|[http://www.vterrain.org Virtual Terrain Project]
|{{Englisch}}
|Eine Seite mit Links und Artikeln zu allem, was etwas mit Terrainrendering zu tun hat.
|-
|}

===Sonstiges===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[Materialsammlung]]
|{{Deutsch}}
|Sammlung von gängigen Parametern für [[glMaterial]] hier im Wiki.
|-
|[http://freespace.virgin.net/hugo.elias/radiosity/radiosity.htm Radiosity]
|{{Englisch}}
|Erklährt sehr schön die Funktionsweise von Radiosity, liefert Beispielcodes und ist recht gut illustriert.
|-
|[http://web.archive.org/web/20050825110920/http://legion.gibbering.net/projectx/paper/shadow%20mapping/ Shadowmapping]
|{{Englisch}}
|Beschreibt das Trapezoidal Shadow Mapping - Verfahren für gerichte Lichter.
|-
|[http://www.flipcode.com/articles/article_generatingnames.shtml Namensgenerator]
|{{Englisch}}
|Per Zufallsgenrator Namen erzeugen, und nie wieder kreativ werden müssen.
|-
|[http://www.paulsprojects.net/tutorials/simplebump/simplebump.html Bumpmapping]
|{{Englisch}}
|Bumpmapping auf Lowend-Grakas. Damals war Bumpmapping noch was ganz tolles...
|-
|[http://www.paulsprojects.net/opengl/dpreflect/dpreflect.html Dot Product Reflect]
|{{Englisch}}
|zwar nur ne Demo, aber wenn man schon immer mal mit EMBM das Wasser aus Morrowind nachproggen wollte...
|-
|}

== Beispiele/Demos mit Quelltext ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.delphigl.de DelphiGL.de]
|{{Deutsch}}
| Hier finden sich besonders eindrucksvolle Newton Physik Demos. Meißtens sogar mit Quelltext.
|-
|[http://www.shadow3d.de.vu/ Shadow 3D]
|{{Deutsch}}
| Hier finden sich zwei Demos wie man Quake 3 Modelle lädt und eine glSlang Demo
|-
|[[Shadersammlung]] im DGL Wiki
|{{Deutsch}}
| Hier findet man freie Shadersourcen.
|-
|[http://www.humus.name Humus]
|{{Englisch}}
| Diverse eindrucksvolle Demos zu verschiedenen Techniken, häufig mit Quelltext in C (teilweise OpenGL / DirectX)
|}

== weitere Links ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www-user.tu-chemnitz.de/~pester/Lehre/CompGeo.pdf CompGeo.pdf]
|{{Deutsch}}
| Script "Einführung in die Computergeometrie" von Dr. Pester (TU-Chemnitz). Ideales Nachschlagewerk für die Mathematik die einem bei der Grafikprogrammierung so begegnet.
|-
|[http://www.robsite.de/ robsite.de]
|{{Deutsch}}
| Auf dieser riesigen Seite finden sich auch viele weitere Links über verschiedene Themen der 3D Programmierung.
|-
|[http://www.3dlinks.com/links.cfm?categoryid=3&subcategoryid=21 3dlinks.com]
|{{Englisch}}
| Diese Seite hat es sich zur Hauptaufgabe gemacht Links auf Seiten mit dem Thema 3D zu sammeln.
|-
|[http://www.two-kings.de/links.html two-kings.de]
|{{Englisch}}
| Sammlung diverser interessanter Links, vorallem auf Themen im gamedev-Forum verweisend.
|-
|[http://www.delgine.com Delgine.com]
|{{Englisch}}
| Heimat des freien 3D Modellers "DeleD", welcher in Delphi programmiert ist. Ihr findet dort auch Modellpackete, Texturpackete, Plugins und Hilfe bei der Programmierung von Delphi und OpenGL.
|}

= Spieleentwicklung =

==Allgemein==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.spieleprogrammierung.net/ Spieleprogrammierung - OpenGL - GLSL - OpenAL - KI - Animation - Spielephysik]
|{{Deutsch}}
|Auf dieser Seite findet Ihr Artikel, Tutorials und Programmbeispiele rund um das Thema Spieleprogrammierung. Programmiersprache ist hier C/C++.
|-
|[http://graphics-and-physics-framework.spieleprogrammierung.net/ OpenGL Graphics And Physics Framework]
|{{Deutsch}}
|Auf dieser Seite findet Ihr ein frei verfügbares OpenGL basiertes Grafik und Physik Framework (LGPL-Lizenz) samt zugehöriger Probammbeispiele. Programmiersprache ist hier C/C++.
|-
|[http://audio-framework.spieleprogrammierung.net/ OpenAL Audio Framework]
|{{Deutsch}}
|Auf dieser Seite findet Ihr ein frei verfügbares OpenAL Audio Framework (LGPL-Lizenz) samt zugehöriger Probammbeispiele. Unterstützt werden 3D Sounds, EFX (EAX Alternative) Reverb Effekte sowie Audio Streaming (Music and Voices). Programmiersprache ist hier C/C++.
|-
|[http://spieleentwicklung-im-web.spieleprogrammierung.net/ Spieleentwicklung im Web]
|{{Deutsch}}
|Auf dieser Seite findet Ihr Links (E-Books, Präsentationen, wissenschaftliche Arbeiten und Tutorials) zu verschiedenen Themengebieten der Spieleentwicklung.
|-
|}

==Kopierschutz==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://inner-smile.com/nocrack.phtml Inner-Smile.com]
|{{Englisch}}
| Seite mit Gedanken zum Thema "Wie schütze ich meine Programme vor Crackern". Falls die Seite nicht erreichbar ist hat Google noch ne [http://www.google.com/search?q=cache:hpqPT5G4WB0J:www.inner-smile.com/nocrack.phtml+http://inner-smile.com/nocrack.phtml&hl=de&gl=de&ct=clnk&cd=1 Version im Archiv].
|-
|}

== Künstliche Intelligenz ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://web.archive.org/web/20080319034335/http://www.kbs.uni-hannover.de/Lehre/KI2/Presentationen/presentation9798/esprit/spieltheorie/spieltheorie.html Uni-Hannover - Spieltheorie]
|{{Deutsch}}
|Artikel über die Grundlagen von KI in Spielen.
|-
|[http://web.archive.org/web/20080927010337/http://www.robsite.de/tutorials.php?tut=ki Robsite KI-Tutorials]
|{{Deutsch}}
| Sammlung von Texten zum Thema KI in Spielen. Beispiele sind meist in C++.
|-
|[http://ai-depot.com/ AI-Depot.com]
|{{Englisch}}
| Seite die sich ausschließlich mit KI in Spielen beschäftigt.
|-
|[http://www.ai-junkie.com/links.html AI-Junkie.com]
|{{Englisch}}
|Linkseite mit vielen KI relevanten Links. Die Seite AI-Junie selbst behandelt auch viele Themen rund um KI.
|-
|[http://www.aiwisdom.com/ AIWisdom.com]
|{{Englisch}}
|Seite die sich mit KIs in Spielen beschäftigt und sich zum Ziel gesetzt hat, alle Artikel zum Thema zu finden und zu Katalogisieren. Es gibt hier auch Artikel über die KIs bestehender Spiele.
|-
|[http://www.aiguru.com/ AIGuru.com]
|{{Englisch}}
|Newsseite zum Thema KI, Künstliches Leben, Hiernforschung, Robotik, Nanotechnologie - Halt alles was Spass macht.
|-
|[http://www.generation5.org/ Generation5.org]
|{{Englisch}}
|Seite über KI, Robotik, etc. . Leider scheint die Seite Probleme zu haben regelmäßig aktualisiert zu werden. Aber zumindest sollte man einige Artikel finden. Die werden ja nicht schlecht.
|-
|[http://web.archive.org/web/20080702005527/http://www.gameai.com/ www.gameai.com]
|{{Englisch}}
|''Wurde Januar 2010 als down gemeldet. Weiss irgendwer etwas genaueres?'' Seite zum Thema KI in Spielen. Soll wohl einen gewissen Stellenwert in der AI-Szene haben.
|-
|[http://www-i1.informatik.rwth-aachen.de/~algorithmus/algo19.php Algorithmus der Woche - Informatikjahr 2006]
|{{Deutsch}}
|Vielleicht schon etwas älter aber doch eine gute Anleitung um eine einfache Schach-KI zu erstellen.
|}

= Ressourcen =
In dieser Gruppe finden sich Links um die Ressourcen für Eure Projekte zu erstellen.

== Texturen / 2D-Grafiken ==

'''Legende:'''
:'''Kostenpflichtige Seiten''' sind mit einem * zu '''kennzeichnen'''
:GPL: Kompatibel mit der GPL
:MPL: Kompatibel mit der MPL
:OSS: Verwendung in OpenSource Software nicht verboten
:CSS: Verwendung in ClosedSource Software nicht verboten
:Komm: Verwendung in kommerzieller Software nicht verboten

=== Texturen ===
{| width = "100%" {{Prettytable_B1}}
!width="20%"|Link
!width="10%"|Genre
!width="10%"|Lizenz
!width="5%"|GPL
!width="5%"|MPL
!width="5%"|OSS
!width="5%"|CSS
!width="5%"|Komm.
!width="35%"|Bemerkungen
|-
|[http://www.davegh.com/vg/home.htm davegh.com]
|Fantasy
|[http://www.davegh.com/vg/termsandconditions.htm Eigene]
|?
|?
|✔
|✔
|✘
|Die Lizenz vererbt sich in die Projekte hinein.
|-
|[http://www.cgtextures.com/ cgtextures.com]
|Allgemein
|[http://www.cgtextures.com/content.php?action=license Eigene]
|✘
|✘
|✘
|?
|?
|Die Lizenz will im wesentlichen verhindern das Texturen in anderen Textursammlungen auftauchen. So wie ich das verstehe ist es kein Problem die Texturen unter einer anderen Lizenz zu veröffentlichen als die eigentliche Software. Die Software kann also sehr wohl OpenSource sein. Im Zweifelsfalls einfach den Support anschreiben, der ist sehr nett.
|-
|url
|Futuristisch, Mittelalter, etc.
|CC-BY-SA, etc., gerne auch mit Direktlink auf die Lizenzseite, so vorhanden.
|✔/✘/?
|✔/✘/?
|✔/✘/?
|✔/✘/?
|✔/✘/?
|Alle Bilder sind von Käse
|}

=== Sonstige 2D-Grafiken ===

{| width = "100%" {{Prettytable_B1}}
!width="20%"|Link
!width="45%"|Beschreibung
!width="10%"|Lizenz
!width="5%"|GPL
!width="5%"|MPL
!width="5%"|OSS
!width="5%"|CSS
!width="5%"|Komm.
|-
|[http://www.famfamfam.com/lab/icons/silk/ famfamfam silk]
|Iconset, welches inzwischen relativ weit verbreitet ist. 700 sauber gezeichnete, erkennbare PNG-Icons in TrueColor. Man kann praktisch jede (Arbeits-)Anwendung mit diesem Set vollständig mit Icons versorgen.
|[http://creativecommons.org/licenses/by/2.5/ CC-BY 2.5], [http://creativecommons.org/licenses/by/3.0/ CC-BY 3.0]
|✔
|✔
|✔
|✔
|✔
|}

=== Texturerstellung ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://3d.diehlsworld.de/textures/index.htm 3d.diehlsworld.de]
|{{Deutsch}}
|Auf dieser Seite findet ihr kurze aber inhaltlich reiche Tutorials zu der Frage "Wie erstelle ich XXXXX-Texturen". Dabei reicht die Palette von Untergrundtexturen wie Gras, Sand , Fels und Wasser (und Kombinationen dieser) bis hin zu Blitzen und Partikeln. Als Programm wird hier Photoshop verwendet.
|-
|[http://www.gimps.de/gimp/textur-muster/ gimps.de]
|{{Deutsch}}
|Schritt für Schritt Anleitungen wie man mit Gimp verschiedene Texturen erstellt.
|-
|[http://cbt.k090999.de/gimp.php#texturen k090999.de]
|{{Deutsch}}
|Gimptutorials zum Erstellen verschiedene Texturen.
|}

== Modelle / 3D-Grafiken ==

=== Blender ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://blendpolis.de/f/viewtopic.php?t=5786 Blendpolis]
|{{Deutsch}}
| Ein Thread im Forum von [http://blendpolis.de Blendpolis] in dem '''sehr''' viele Tutorials aufgelistet sind
|-
|[http://blendpolis.de/f/article_cat.php?fldAuto=7 Blendpolis]
|{{Deutsch}}
| Eigentliche Tutorial Seite von [http://blendpolis.de Blendpolis] die Auswahl ist hier aber nicht so groß
|-
|[http://wikivid.com/index.php/Blender Blender at wikivid.com]
|{{Englisch}}
| Linksammlung von Blender Video Tutorials
|-
|[http://www.blender.org/education-help/tutorials/getting-started/ blender3d.org]
|{{Englisch}}
| Auch die Heimatseite von Blender bietet viele Tutorials unter anderm auch Video Tuorials
|-
|[http://www.Blenderunderground.com Blenderunderground]
|{{Englisch}}
| '''sehr gute''' Video-Tutorials
|}

== Sounds ==

===Musik===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.jamendo.com/ Jamendo.com]
|{{Englisch}}
|Viele Künstler stellen hier ihre Alben unter einer Creative Commons Lizenz online. Man kann dort die Künstler auch kontaktieren und fragen ob man ihre Musik nutzen kann. Taugt außerdem als Radio! ;)
|-
|[http://incompetech.com/m/c/royalty-free/ Incompetech.com]
|{{Englisch}}
|Viele sehr schön gemacht instrumentale Musik aus allen möglichen Genres. Sie ist frei verwenderbar, wenn man den Macher der Musik (Kevin MacLeod) in seinem Programm erwähnt. Aber das hat er auch verdient. Folgende Programme nutzen beispielsweise (auch) Musik von incompetech.com:
* OpenParty
|-
|}

===Soundeffekte===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.freesound.org/ freesound.org]
|{{Englisch}}
|Diverse Sounds unter [http://www.creativecommons.org/ CreativeCommons] Lizenzen.
|}

===Soundprogramme===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://audacity.sourceforge.net/?lang=de Sourceforgeseite von Audacity]
|{{Deutsch}}
|Ein einfaches, freies Programm um Sounddateien zu bearbeiten. Man kann es auch nutzen um Soundeffekte neu zu erstellen, indem man z.B. ein Geräusch mit dem Mikrofon aufnimmt und einige Effekt anwendet, um es passender und nicht mehr aufgenommen klingen zu lassen.
|-
|[http://lmms.sourceforge.net/ LMMS]
|{{Englisch}}
|LMMS (Linux MultiMedia Studio) ist ein OpenSource+Freeware Composer-Programm ähnlich zum bekannteren aber auch teuren CuBase(r). Trotz des Namens auch für Windows erhältlich.
|}

Benutzer:Lord Horazont/Tutorial Versionskontrolle mit GIT

2011-09-23T15:51:33Z

Lord horazont: Working draft

= Versionskontrolle mit git =

Hallo und herzlich willkommen zu meinem dritten Tutorial. Heute soll's um Versionskontrolle gehen und zwar demonstriert anhand von git. Warum überhaupt Versionskontrolle? Warum für Hobbyprojekte? Was ist git? Wie macht man das? – diese und andere Fragen werde ich (hoffentlich) beantworten.

== Theorie der Versionskontrolle ==

Nun, jeder der schon einmal einen Wikiartikel geschrieben hat, hatte schon indirekt Kontakt mit Versionskontrolle. Sowas ist nämlich in jedes MediaWiki eingebaut. Immer, wenn man einen Artikel bearbeitet, wird die vorherige Version erhalten, man kann sie später anschauen oder Änderungen rückgängig machen.

Dies gibts nicht nur für Webseiten wie unser Wiki, sondern, in anderer Form, auch für Projekte. Viele werden schonmal irgendwo SVN oder CVS gehört haben, weniger von GIT oder Mercurial. Diese vier sind vermutlich die populärsten Versionskontrolle-Werkzeuge, die im Moment im Einsatz sind.

== Häufige Probleme… ==

=== Problem 1: Mist gebaut? ===
Der große Vorteil der Versionskontrolle liegt auf der Hand. Habt ihr schonmal selbstsicher angefangen, an einem Feature zu arbeiten, dann festgestellt, dass es irgendwie nicht ganz so gut läuft wie erwartet und zum schluss einen Haufen Konflikte im Code gehabt? Da hilft meist nur noch eins: Rückgängig drücken, und zwar oft. Mist! Das Undo-Limit der IDE ist erreicht, aber nichtmal die Hälfte der Änderungen wurden rückgängig gemacht. Dann hat man noch die Möglichkeit, auf ein Backup zurückzugreifen (falls das überhaupt existiert), oder eben alles von Hand wieder Rückgängig machen.

=== Problem 2: Zusammenarbeit ===
Anderes Szenario: Man hat ein Projekt, was gut läuft und was andere (Programmierer) interessant finden. Sie möchten Beitragen, aber natürlich hat man eher wenig Lust immer Archive mit allen Sourcedateien per Mail oder sonstwas zu verschicken. Auch will man den Leuten nicht unbedingt Schreibzugriff auf den eigenen Rechner geben. Also könnte man immer noch, um das Datenvolumen zu reduzieren, Patches verschicken.

== … und ihre Beseitigung durch Versionskontrolle ==
Aus beiden Szenarien gibt es einen gemeinsamen Ausweg: Versionskontrolle und Repositories solcher müssen her!

Anhand von git sei nun im folgenden gezeigt, wie man die beiden genannten Probleme umgeht. Aber wir wollen von Grund auf anfangen, damit ihr das ganze gleich sofort ausprobieren könnt. Dazu beginnen wir damit, wie man Git verwendet. Es sei vorrausgesetzt, dass ihr mit dem Terminal (oder der git-bash, was nichts weiter als eine Bash mit Git für Windows ist) umgehen könnt. Außerdem sollte Git bzw. die Git-Bash natürlich installiert sein ;).

== Ein Git-Repository anlegen und befüllen ==
Das ist recht einfach. Wir wechseln (mit {{INLINE CODE|cd}}) in das Verzeichnis, wo wir ein Git-Repository anlegen wollen. Das ist im optimalfall leer oder das Wurzelverzeichnis unseres Projektes. Dann initialisieren wir ein git Repo mit:

$ git init

War einfach, oder? Jetzt können wir schauen, was git so sagt (vorrausgesetzt, es sind schon Dateien im Verzeichnis, sonst erstmal ein Projekt oder so reinkopieren):

$ git status

Das sollte eine Ausgabe ähnlich dieser erzeugen:
# On branch master
#
# Initial commit
#
# Untracked files:
# (use "git add <file>..." to include in what will be committed)
#
# <font color="#7f0000">a</font>
# <font color="#7f0000">b</font>
nothing added to commit but untracked files present (use "git add" to track)
Wobei anstatt a und b bei euch vermutlich andere Dateien und Verzeichnisse aufgelistet sind. Diese können wir nun mit:
$ git add file1 file2 …
hinzufügen. Das geht aber auch einfacher:
$ git add directory/* # fügt alle Dateien im Verzeichnis directory hinzu (mit Unterverzeichnissen)
$ git add directory # wie oben
$ git add *.c # fügt alle Dateien, die auf .c enden und im Wurzelverzeichnis liegen hinzu
$ git add directory/*.c # könnt ihr sicher erraten: fügt alle Dateien, die auf *.c enden und in directory liegen hinzu (sollte dort ein Ordner auf .c
enden, wird dieser auch hinzugefügt…)
$ git add -A # fügt *alle* dateien, die es im Ordner finden kann, hinzu. Kann zu viel sein, evtl. mit git rm --cached wieder welche entfernen.
Soweit. Nun haben wir git mitgeteilt, dass wir diese Dateien hinzufügen wollen. Das müssen wir noch ''committen'', sozusagen „amtlich“ machen:
$ git commit -v
Das wird euren bevorzugten Terminal-Editor öffnen und ihr könnt eine Commit-Message eingeben, die später im Log zu diesem „Commit“ auftauchen wird. Ein „Commit“ ist sozusagen ein Satz an Änderungen, der logisch zusammen gehört. Was logisch zusammen gehört, definiert sich daran, was ihr zusammen committed ;). Wenn nichts schief gegangen ist, wird git sowas sagen wie:
[master (root-commit) 050a498] * Bla
0 files changed, 0 insertions(+), 0 deletions(-)
create mode 100644 bla/bakery/bread
create mode 100644 bla/cookie
create mode 100644 bla/keks
create mode 100644 c.c
Ansonsten sollte die Fehlermeldung aufschluss darüber geben, was nicht geklappt hat. Eventuell möchte git, dass ihr ihm sagt, wer ihr seid. Das tut ihr mit den Befehlen, die es euch da vorschlägt. Diese Informationen werden in die Commits mit eingebunden, damit man diese den Entwicklern zuordnen kann.

== Änderungen durchführen und committen ==
Nun können wir an unserem Code rumschreiben. Wenn wir einen Schritt weiter zu unserem Ziel gekommen sind, können wir die Änderungen ins Repo committen. Ich mache das meist, wenn ich kompilierfähigen Code habe oder wenn ich einen größeren Schritt erledigt habe oder wenn ich von einer logischen Einheit des Codes in eine andere wechsle (z.B. unterschiedliche Packages oder Module). Jetzt können wir entweder alle Dateien, die wir geändert oder neu hinzugefügt haben mit
$ git add path/to/file.pp path/to/file2.pp
“stagen”, d.h. für den Commit vorsehen, oder wir nutzen
$ git commit -av
wobei das “a” in der Kommandozeile sagt, dass es automatisch alle geänderten Dateien mit in den Commit aufnehmen soll. Beachtet aber, dass es neu erstellte Dateien nicht als “changed” sondern als “untracked” sieht, also werden sie nicht beachtet. Neu erstellte Dateien muss man explizit mit
$ git add path/to/new/file.pp
ankündigen. Das kann man aber ohne Probleme zusammen mit {{INLINE CODE|git commit -av}} benutzen, sodass man nur die neu erstellten Dateien mit {{INLINE CODE|git add}} stage't, aber die anderen mit {{INLINE CODE|git commit -av}}.

$ git log
sollte nun schon ein paar schöne Commits ausgeben.

== Pushs, Fetchs, Merges, Pulls und Branches ==
Ähhh. Was? Ok, der Reihe nach.

== “A successful git branching model” ==
Auf [http://nvie.com/posts/a-successful-git-branching-model/ dieser Seite] bin ich auf ein sehr hilfreiches Arbeitsmodell für das Arbeiten mit Branches unter Git gestoßen. Das könnt ihr euch am besten Ausdrucken und an die Wand pinnen.

Diskussion:DGL Treffen/2011/Organisation

2011-09-02T17:36:01Z

Lord horazont: 7=max

== 7=max ==

Ohne hier spammen zu wollen, 7=max, drei von vier haben aber 8 tage angegeben ;)

grüße --[[Benutzer:Lord horazont|Lord horazont]] 19:36, 2. Sep. 2011 (CEST)

Tutorial glsl

2011-08-25T15:20:53Z

Lord horazont: /* Strukturen */ Index beim beispielhaften LightSource-Zugriff korrigiert

=Einleitung=
Hallo und willkommen bei meiner "Einführung" in GLSL (kurz für "Open'''GL''' '''S'''hading '''L'''anguage"), der offiziellen Hochlevel-Shadersprache von OpenGL. In diesem umfangreichen Dokument werde ich versuchen, sowohl auf die Nutzung (sprich das Laden und Anhängen von Shadern im Quellcode), als auch auf die Programmierung von Shadern selbst einzugehen, inklusive aller Sprachelemente der OpenGL Shadersprache. Es wird also auch recht viele Informationen zu der C-ähnlichen Programmstruktur und den von GLSL angebotenen Variablen und Attributen gehen. Am Ende dieser Einführung sollten alle die, die sich für das Thema interessieren, in der Lage sein, zumindest einfach Shader zu schreiben und auch in ihren Programmen zu nutzen. Ausserdem soll dieses Dokument gleichzeitig als ein deutsches "Pendant" zu den von Khronoes veröffentlichten Shaderspezifikationen, und damit als alltägliches Nachschlagewerk, dienen.

==Vorkenntnisse==
Wie auch schon mein ARB_VP-Tutorial richtet sich auch diese Einführung aufgrund ihrer Thematik eher an die fortgeschritteneren GL-Programmierer und neben sehr guten GL-Kenntnissen sollten sich alle, die sich daran versuchen wollen, mit den technischen Hintergründen der GL, wie z.B. dem Aufbau der Renderpipeline auskennen. Weiterhin sind C-Kenntnisse absolut erforderlich, da die Shader ja in einer an ANSI-C angelehnten Syntax geschrieben werden. Auch Begriffsdefinitionen zu Vertex oder Fragment werden zum Verständis dieser Einführung benötigt. Wer also noch am Anfang seiner GL-Karriere steht, dem wird dieses Dokument nicht viel nützen. Ganz nebenbei solltet ihr auch noch eine gehörige Portion Zeit (am besten nen kompletten Nachmittag) mitbringen, denn die folgende Kost ist nicht nur umfangreich, sondern auch manchmal recht schwer verdaulich.

=Was ist GLSL?=
Wie Eingangs kurz angesprochen handelt es sich bei GLSL um eine Shadersprache, also um eine Hochsprache, in der man die programmierbaren Teile aktueller Grafikbeschleuniger nach eigenem Belieben programmieren kann. Sie stellt quasi den Nachfolger zu den in Assembler geschriebenen Vertex- und Fragmentprogrammen ([[GL_ARB_vertex_program]]/[[GL_ARB_fragment_program]]) dar und basiert auf ANSI C, erweitert um Vektor- und Matrixtypen sowie einige C++-Mechanismen.

Die in GLSL geschriebenen Programme nennen sich, angepasst an die Terminologie von RenderMan und DirectX, [[Shader]] (im Gegensatz zu "Programme" bei ARB_VP/FP) und werden entweder auf Eckpunkte (VertexShader), Fragmente (FragmentShader) angewendet, oder (neuerdings, ab Shadermodell 4.0) auch genutzt um Geometrie zu erstellen (Geometryshader). Andere Teile der Renderpipeline (z.B. die Rasterisierung) können momentan noch nicht durch Shader beeinflusst werden, was allerdings in Zukunft noch kommen kann.

==Voraussetzungen==

GLSL wurde 2005 mit OpenGL 1.5 eingeführt. Während es in Sachen Treiber- und Hardwareunterstützung anfänglich noch dürftig aussah, wird man inzwischen keine Grafikkarte mehr kaufen können die nicht zumindest Vertex- und Fragmentshader beherscht. Geometrieshader hingegen sind relativ neu und wurden erst mit Shadermodell 4.0 eingeführt, hier ist es also unter Umständen noch möglich dass selbst aktuelle Treiber/Karten keine Geometrieshader beherrschen.

Natürlich benötigt man auch einen passenden OpenGL-Header der die für GLSL nötigen Funktionen exportiert. Ich verweise dazu auf unseren eigenen OpenGL-Header [[DGLOpenGL.pas]], der peermanent auf dem aktuellsten Stand gehalten wird und auch Support für Geometrieshader mitbringt.

==Extensions==

Die GL-Shadersprache "besteht" in ihrer aktuellen Version aus folgenden Extensions, fürs Verständnis wäre es nicht schlecht, wenn ihr euch zumindest die Einleitungen dazu durchlest :
* [[GL_ARB_shader_objects]] ([http://oss.sgi.com/projects/ogl-sample/registry/ARB/shader_objects.txt Originalspezifikation])
: Definiert die API-Aufrufe, die zum Erstellen, Kompilieren, Linken, Anhängen und Aktivieren von Shader- und Programmobjekten nötig sind.
* [[GL_ARB_vertex_shader]] ([http://oss.sgi.com/projects/ogl-sample/registry/ARB/vertex_shader.txt Originalspezifikation])
: Fügt der OpenGL Programmierbarkeit auf Vertexebene hinzu.
* [[GL_ARB_fragment_shader]] ([http://oss.sgi.com/projects/ogl-sample/registry/ARB/fragment_shader.txt Originalspezifikation])
: Fügt der OpenGL Programmierbarkeit auf Fragmentebene hinzu.
* [[GL_ARB_shading_language_100]] ([http://oss.sgi.com/projects/ogl-sample/registry/ARB/shading_language_100.txt Originalspezifikation])
: Gibt die unterstützte Version von glSlang an, momentan 1.00.

'''Hinweis''' : Seit OpenGL 2.0 ist GLSL Teil des Kerns. Wenn die Karte also OpenGL 2.0 unterstützt, dann unterstützt sie auch (zumindest in Software) Vertex- und Fragmentshader.

==Sprachversionen==

Neben der OpenGL-Version und dem vorhandenen Shadermodell (das eher an DirectX ausgerichtet ist), bietet auch GLSL verschiedene Versionen, die entsprechend erweiterte Funktionalität bieten.

Auslesen kann man die verfürgbare GLSL-Version wie folgt:

glGetString(GL_SHADING_LANGUAGE_VERSION)

Erst ab Version 1.4. kann man davon ausgehen dass GLSL alle Features des Shadermodells 4.0 liefert, ab 1.3 grob gesagt Shadermodell 3.0 (bei GLSL lässt sich das leider nicht so leicht unterteilen).

Ausserdem kann man seinem Shader eine Versionsnummer verpassen. Sollte der Shadercompiler (also Treiber bzw. Hardware) diese Version nicht unterstützen, gibt dieser eine Fehlermeldung heraus:

#version 1.50

''(Hinweis: Muss am Anfang des Shaders stehen)''

==Objekte==

Im Zuge der Vereinheitlichung der GL wird immer häufiger in Objekte gekapselt, deren API dann auch aneinander angelehnt ist. Ziel ist, dabei die Programmierung der GL uniform zu machen, so dass z.B. zwischen dem Erstellen und Verwalten eines Vertex-Buffer-Objektes oder eines Shader-Objektes kaum ein Unterschied besteht (demnächst kommen dann auch Pixel-Buffer-Objekte dazu). Mit glSlang wurden dann im Zuge dieser Aktion zwei neue Objekte eingeführt, deren Definition ihr euch unbedingt einprägen solltet:

* '''Programmobjekt'''
:Ein Objekt, an das die Shader später angebunden werden. Bietet Funktionalität zum Linken der Shader und prüft dabei die Kompatibilität zwischen Vertex- und Fragmentshader.

* '''Shaderobjekt'''
:Dieses Objekt verwaltet den Quellcodestring eines Shaders und ist entweder vom Typ '''GL_VERTEX_SHADER''', '''GL_FRAGMENT_SHADER_ARB''' oder '''GL_GEOMETRY_SHADER'''.

==Ressourcen==

Die Shadersprache ist keinesfalls final und es wurden bereits diverse Ausdrücke für zukünftige Verwendung reserviert, denn ein Ziel bei ihrer Entwicklung war es, sie so zukunftsorientiert zu gestalten, dass auch Grafikkarten der nächsten und übernächsten Generation voll ausgenutzt werden können. Damit einher geht die Tatsache, dass sich die Spezifikationen in Zukunft ändern/erweitern werden, weshalb man da immer einen Blick hineinwerfen sollte. Die Anlaufstelle dafür ist die [http://www.opengl.org/documentation/specs/ Spezifikationenliste auf OpenGL.org].

=GLSL im Programm=
Bevor wir uns mit der Syntax von glSlang beschäftigen, zeige ich euch erstmal, wie ihr Shader in euer Programm einbindet und nutzt. Warum das zuerst? Ganz einfach deshalb, weil ihr dann das, was ihr im glSlang-Syntaxteil lernt, direkt in eurer Testanwendung verwenden könnt. Hoffe diese Entscheidung klingt logisch und findet Anklang.

Zuerst benötigen wir natürlich unsere Objekte. Zum einen ein ''Programmobjekt'', an das unsere Shader gebunden werden, und zwei ''Shaderobjekte'', die den Quellcode unseres Vertex bzw. Fragment Shaders aufnehmen. Dazu wurde eigens der neue "Datentyp" {{INLINE_CODE|glHandle}} eingeführt, der ein Objekthandle repräsentiert. Wir deklarieren also wie folgt :

ProgramObject : GLhandle;
VertexShaderObject : GLhandle;
FragmentShaderObject : GLhandle;

Nach dieser Deklaration können wir dann damit beginnen unsere Objekte zu erstellen. Den Anfang macht das Programmobjekt :

ProgramObject := glCreateProgram;

Die Funktion [[glCreateProgram]] erstellt uns oben ein leeres Programmobjekt und gibt ein gültiges Handle darauf zurück.

Weiter gehts mit der Erstellung unseres Vertex bzw. Fragment Shaders :

VertexShaderObject := glCreateShader(GL_VERTEX_SHADER);
FragmentShaderObject := glCreateShader(GL_FRAGMENT_SHADER);

[[glCreateShader]] dient zur Generierung eines leeren Shaderobjektes. Momentan unterstützt diese Funktion VertexShader und FragmentShader.

Nachdem wir nun also zwei gültige Shaderobjekte haben, wollen wir diese auch mit entsprechendem Quellcode versorgen :

glShaderSource(VertexShaderObject, 1, @ShaderText, @ShaderLength);
glShaderSource(FragmentShaderObject, 1, @ShaderText, @ShaderLength);

Via [[glShaderSource]] setzen wir den Quellcode eines Shaderobjektes ''komplett'' neu. Zum Laden des Quellcodes bietet sich unter Delphi übrigens eine TStringList geradezu an. Es sollte beachtet werden, dass der Quellcode zu diesem Zeitpunkt ''nicht geparst'' wird, also keine Fehleruntersuchung stattfindet.

Der Quellcode wurde jetzt also an unsere Shaderobjekte gebunden und sollte dann natürlich auch noch kompiliert werden :

glCompileShader(VertexShaderObject);
glCompileShader(FragmentShaderObject);

Der glSlang-Compiler des Treibers wird bei einem Aufruf von [[glCompileShader]] versuchen, unsere Shader zu kompilieren. Sofern diese keine Fehler aufweisen, sollte dies auch erfolgreich sein. Wenn nicht, dann spuckt uns der Shadercompiler (je nach Treiber) recht detaillierte Infos aus. Wie man an diese Infos kommt könnt ihr gleich nachlesen.

Wenn unsere Shader dann kompiliert werden konnten, ist es Zeit, diese an unser anfangs erstelltes Programmobjekt anzuhängen :

glAttachShader(ProgramObject, VertexShaderObject);
glAttachShader(ProgramObject, FragmentShaderObject);

Nachdem die Shaderobjekte nun an das Programmobjekt angehängt wurden, werden diese nicht mehr benötigt und ihre Resourcen können freigegeben werden :

glDeleteShader(VertexShaderObject);
glDeleteShader(FragmentShaderObject);

Am Schluß müssen wir dann noch unsere ans Programmobjekt gebundenen Shader linken :

glLinkProgram(ProgramObject);

Während [[glCompileShader]] unsere Shader auf syntaktische Fehler innerhalb ihres lokalen Raums geprüft hat, werden beim Linken durch [[glLinkProgram]] die angehangenen Shader zu einem ausführbaren Shader gelinkt. Folgende Bedingungen führen zu einem '''Linkerfehler''':

* Die Zahl der von der Implementation unterstützten Attributvariablen wurde überschritten
* Der Speicherplatz für Uniformvariablen wurde überschritten
* Die Zahl der von der Implementation angebotenen Sampler wurde überschritten
* Die main-Funktion fehlt
* Die Liste der Varying-Variablen des Vertexshaders stimmt nicht mit der des Fragmentshaders überein
* Funktions- oder Variablenname nicht gefunden
* Eine gemeinsame Globale ist mit unterschiedlichen Werten oder Typen initialisiert worden
* Zwei Sampler unterschiedlichen Typs zeigen auf die selbe Textureneinheit
* Ein oder mehrere angehangene(r) Shader wurden nicht erfolgreich kompiliert

Die Nutzung von glSlang im eigenen Programm ist wie oben erkennbar also nicht wirklich schwer und innerhalb kurzer Zeit realisiert. Natürlich ist es auch möglich z.B. nur einen VertexShader oder nur einen FragmentShader an ein Programmobjekt zu binden.

Noch eine kleine Notiz zum Löschen der Shader mittel [[glDeleteShader]] : Da Shader(objekte) einen Referenzzähler besitzen und erst gelöscht werden wenn diese nirgendwo mehr benötigt werden, ist es nicht falsch diese vor dem Linkvorgang zu löschen. Allerdings spielt es letztendlich keine Rolle ob die Löschanweisung vorher der nachher ausgeführt wird.

==Fehlererkennung==
Natürlich wird es ohne Fehlerausgabe recht schwer, etwaige Probleme in einem Vertex- oder Fragmentshader zu finden. Doch auch in diesem Bereich wurde glSlang recht gut durchdacht und es wurden zwei Funktionen eingeführt, welche im Zusammenspiel die Fehlersuche recht einfach machen, nämlich [[glGetShaderInfoLog]] und [[glGetShader]] mit dem Argument {{INLINE_CODE|GL_OBJECT_INFO_LOG_LENGTH}}. Erstere Funktion liefert uns einen Logstring, während uns letztere Funktion dessen Länge angibt. Der Logstring wird verändert, sobald ein Shader kompiliert oder ein Programm gelinkt wird.

Um die Ausgabe dieses Logs so einfach wie möglich zu machen, bietet es sich an beide in einer einfach Funktion unterzubringen :

<source lang="pascal">function glSlang_GetInfoLog(pShader: GLHandleARB): String;
var
blen, slen: GLInt;
InfoLog: PGLCharARB;

begin
glGetShaderiv(glObject, GL_INFO_LOG_LENGTH , @blen);
if blen > 1 then
begin
GetMem(InfoLog, blen * SizeOf(GLCharARB));
glGetShaderInfoLog(pShader, blen, slen, InfoLog);
Result := PChar(InfoLog);
Dispose(InfoLog);
end;
end;</source>

Die Funktion ist recht leicht erklärt : Zuerst lassen wir uns über {{INLINE_CODE|glGetShaderiv}} mitteilen wie lang der aktuelle Infolog ist. Sollte dort tatsächlich etwas drinstehen (blen > 1), dann lassen wir uns dessen Inhalt via {{INLINE_CODE|glGetShaderInfoLog}} in {{INLINE_CODE|InfoLog}} ausgeben und liefern diesen als Ergebnis zurück.

Wie bereits gesagt wird nur nach dem Kompilieren eines Shaders bzw. dem Linken eines Programmobjektes ein Infolog erstellt. Es bietet sich dadurch an, direkt danach einen solchen Aufruf zu machen :

glCompileShader(VertexShaderObject);
ShowMessage(glSlang_GetInfoLog(VertexShaderObject));

Wenn unser Vertex Shader komplett fehlerfrei kompiliert werden konnte, dann sehen wir als Ergebnis nur einen leeren Dialog. Ist dies nicht der Fall, so werden wir vom Treiber mit recht detaillierten Fehlerinformationen "belohnt", z.B. so :

[[Bild:GLSL_error_vshader.jpg]]

Auch das Infolog nach dem Linken des Programmobjektes dürfte, selbst wenn keine Fehler vorkommen, recht interessant sein, das sieht dann nämlich so aus :

[[Bild:GLSL info programobject.jpg]]

Wie zu sehen, wird uns nach dem erfolgreichen Linken auch gesagt, ob und welcher Shader in Hardware bzw. Software läuft. Für Debuggingzwecke sicherlich eine mehr als brauchbare Information.

==Shader benutzen==
Um den Shader auch für die nächsten Polygone zu benutzen oder Uniformparameter übergeben zu können, ruft man die Funktion
glUseProgramt(ProgramObject);
um alle Shader zu deaktivieren, ruft man dieselbe Funktion mit dem Parameter 0.

==Parameterübergabe==
Uniformparameter (mehr dazu später) stellen die Schnittstelle zwischen eurem Programm und dem Shader dar, werden also genutzt um Daten aus dem Programm heraus an einen Shader zu übergeben. Zur Übergabe dieser Parameter bietet OpenGL diverse Funktionen, die alle Abkömmlinge von [[glUniform]] sind. Während mit {{INLINE_CODE|glUniform4f}} z.B. ein Vier-Komponentenvektor an das Programmobjekt übergeben wird, kann man mittels {{INLINE_CODE|glUniformMatrix4fv}} ganze Matrizen schnell und einfach übergeben. Ausserdem gibt es nun die Möglichkeit Uniformparameter direkt über ihren Namen, statt wie unter ARB_FP/VP über einen festen Index zu adressieren. Die Funktion [[glGetUniformLocationARB]] gibt anhand des übergebenen Parameternamens dessen Position zurück. Man kann also ganz einfach über den Namen drauf zugreifen :

glUniform3f(glGetUniformLocation(ProgramObject, PGLCharARB('LightPosition')), LPos[0], LPos[1], LPos[2]);
glUniform1i(glGetUniformLocation(ProgramObject, PGLCharARB('texSamplerTMU3')), 3);

Wichtig ist hier, das man je nach Parametertyp auch die passende Anzahl von Argumenten übergibt. Also für einen 4-Komponenten Floatvektor {{INLINE_CODE|glUniform4fARB}} und für einen einfachen Integerwert (z.B. Textureinheit für einen Sampler) glUnifrom1iARB. Auch nicht vergessen dürft ihr, das die Namen der Parameter genauso wie im Shader geschrieben werden müssen, also Groß- und Kleinschreibung beachtet werden muß.

=Die Shadersprache=

Nachdem wir uns mit der Einbindung der glSlang-Shader in unser Programm beschäftigt haben, wollen wir uns in den folgenden Kapiteln um die Sprachelemente von glSlang kümmern. Wie schon gesagt basiert glSlang auf ANSI-C, wurde allerdings um speziell auf den Zielbereich angepasste Vektor- und Matrixtypen und einige C++-Features wie das freie deklarieren von Variablen an jeder Stelle und das Funktionsüberladen auf Basis des Argumenttyps erweitert. Wer sich ein wenig mit C/C++ auskennt sollte also in der nun folgenden Materie keine Probleme bekommen.

'''Obligatorische Hinweise für verwöhnte Delphi-Nutzer : '''
*Wie von C/C++ her gewohnt, spielt auch in glSlang die Groß- und Kleinschreibung eine wichtige Rolle, also bitte achtet darauf. gl_Position ist eine komplett andere Variable als z.B. gl_position.
*Es findet keine automatische Typenkonvertierung statt. Das bedeutet also das float MyFloat = 1 ungültig ist und es in dem Falle float MyFloat = 1.0 heissen muss. Typecasts müssen also immer manuell stattfinden, z.B. MyFloat = float(MyInt).

'''Kleine Programmstrukturkunde für C-Unkundige :'''<br>
Da sicherlich einige Delpher nie richtig was mit C gemacht haben, zeige ich mal anhand eines kleinen Beispieles (das auf keinen Fall nen brauchbaren Shader darstellt) den grundlegenden Aufbau eines glSlang-Shaders, der natürlich dem Aufbau eines C-Programmes stark ähnelt :
<source lang="glsl">
uniform vec4 VariableA;
float VariableB;
vec3 VariableC;
const float KonstanteA = 256.0;

float MyFunction(vec4 ArgumentA)
{
float FunktionsVariableA = float(5.0);

return float(ArgumentA * (FunktionsVariableA + KonstanteA));
}

// Ich bin ein Kommentar
/* Und ich auch */
void main(void)
{
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
gl_TexCoord[0] = gl_MultiTexCoord0;
}
</source>

Sieht doch recht bekannt aus, unser Programmaufbau. Delphi und C haben ja so einige Grundlagen gleich, darunter auch der ungefähre Programmaufbau. Ausserhalb jeglicher Funktionen legen wir am Programmanfang unsere Variablen, Konstanten und Attribute fest, die dann ''global'' nutzbar sind, also in jeder Funktion.

Darunter deklarieren wir dann eine kleine Funktion. Wie auch bei den Variablendeklarationen wird hier der Rückgabetyp nicht wie bei Pascal nach dem Funktionsnamen untergebracht, sondern davor. Innerhalb der Funktion können dann wieder Variablen deklariert werden, die dann allerdings ''lokal'', also nur in dieser Funktion nutzbar sind. Vorteil dieser Deklaration ist die Tatsache, dass je nach Grafikkarte nur bestimmt viele globale Variablen deklariert werden können. Wenn möglich sollte man also mit lokalen Vorlieb nehmen. Unsere Funktion gibt dann natürlich noch via return einen Wert zurück, ''was gemacht werden muss'', sofern man diese nicht als void deklariert hat (entspräche dann einer Prozedur in Pascal). Wird dies nicht getan, so spuckt der Compiler einen Fehler aus.

Auch wichtig sind natürlich Kommentare. Erste Variante (Doppelslash) ist auch in der Pascalwelt verfügbar und kommentiert eine einzelne Zeile aus. Die Variante darunter kann man für Kommentarblöcke nutzen (/* .. */) und entspricht den Kommentaren in geschweiften Klammern in Delphi.

Danach kommt dann die '''wichtigste Funktion''' des Shaders, nämlich '''main''', die in keinem Shader fehlen darf. Sie stellt quasi den Programmkörper dar und ist oft auch die einzige Funktion in einem Shader. Sie erhält weder ein Argument, noch gibt sie einen Wert zurück.

Soviel also zum grundlegenden Aufbau eines Shader. Hoffe das jetzt alle die in C nicht so bewandert sind damit klar kommen, und dann bald ihre ersten glSlang-Shader schreiben können.

==Datentypen==

Obwohl einige Datentypen aus C übernommen wurden, sieht man der Typenliste an, das diese speziell auf den 3D-Bereich zugeschnitten wurde. Variablen müssen vor ihrer Nutzung eindeutig deklariert sein, Typecasting erfolgt über Konstruktoren (dazu später mehr). Folgende Datentypen stehen sowohl im Vertex- als auch Fragmentshader zur Verfügung :

{|{{Prettytable_B1}}
!Datentyp
!Erklärung
|-
|void
|Für Funktionen die keinen Wert zurückgeben
|-
|bool
|Konditionaler Typ, entweder true (wahr) oder false (falsch)
|-
|int
|Vorzeichenbehafteter Integerwert
|-
|float
|Fließkommaskalar mit Singlegenauigkeit (32 Bit)
|-
|vec2
|2-Komponenten Fließkommavektor
|-
|vec3
|3-Komponenten Fließkommavektor
|-
|vec4
|4-Komponenten Fließkommavektor
|-
|bvec2
|2-Komponenten Booleanvektor
|-
|bvec3
|3-Komponenten Booleanvektor
|-
|bvec4
|4-Komponenten Booleanvektor
|-
|ivec2
|2-Komponenten Integervektor
|-
|ivec3
|3-Komponenten Integervektor
|-
|ivec4
|4-Komponenten Integervektor
|-
|mat2
|2x2 Fließkommamatrix
|-
|mat3
|3x3 Fließkommamatrix
|-
|mat4
|4x4 Fließkommamatrix
|}

Die sampler-Typen stellen eine besondere Klasse zum Zugriff auf Texturen dar, und werden im Kapitel 6.7 genauer erklärt, inklusive einiger Anwendungsbeispiele.

{|{{Prettytable_B1}}
!Datentyp
!Erklärung
|-
|sampler1D
|Zugriff auf 1D-Textur
|-
|sampler2D
|Zugriff auf 2D-Textur
|-
|sampler3D
|Zugriff auf 3D-Textur
|-
|samplerCube
|Zugriff auf Cubemap
|-
|sampler2DRect
|Zugriff auf Texturen die nicht 2^n * 2^n entsprechen ("non power-of-two", NPOT)
|-
|sampler1DShadow
|Zugriff auf 1D-Tiefentextur mit Vergleichsoperation
|-
|sampler2DShadow
|Zugriff auf 2D-Tiefentextur mit Vergleichsoperation
|-
|samplerCubeShadow
|Zugriff auf Tiefentextur in einer Cubemap (z.b. für omni-diretionale Lichtquellen)
|-
|sampler2DRectShadow
|Zugriff auf 2D-NPOT-Tiefentextur
|-

|sampler1DArray
|Zugriff auf ein array aus 1D-Texturen
|-
|sampler2DArray
|Zugriff auf ein array aus 2D-Texturen
|-
|sampler1DArrayShadow
|Zugriff auf ein array aus 1D-Tiefentexturen
|-
|sampler2DArrayShadow
|Zugriff auf ein array aus 2D-Tiefentexturen
|-
|samplerBuffer
|Zugriff auf eine Puffertextur (1D-Texutr zum Speichern von Pufferobjekten)
|-
|sampler2DMS
|Zugriff auf eine 2D-Textur mit mehreren Samplepunkten (z.b. für Multisampling)
|-
|sampler2DMSArray
|Zugriff auf einarray aus 2D-Textur mit mehreren Samplepunkten (z.b. für Multisampling)
|-
|}

===Arrays===

Natürlich unterstützt glSlang auch Arrays, die wie in C deklariert werden und deren Index bei 0 beginnt. Folgendes Array im Shader :
<source lang="glsl">
float temp[3];
</source>
beginnt also bei Index 0 und endet bei Index 2. Im Gegensatz zu C lassen sich Arrays in glSlang allerdings ''nicht bei der Initialisierung vorbelegen''. Wenn ein Array als Parameter einer Funktion deklariert wird, so darf dieses keine Dimensionierung erhalten.

===Strukturen===

Neu ggü. ARB_FP/VP ist nun auch die Möglichkeit, Strukturen in einem Shader zu deklarieren. Vor allem die Übersicht komplexerer Shader kann dadurch stark verbessert werden. Strukturen werden wie gewohnt mit dem Schlüsselwort {{INLINE_CODE|struct}} eingeleitet und können dann zur Typisierung von Variablen genutzt werden. Folgendes Beispiel dürfte die Nutzung verdeutlichen :
<source lang="glsl">
struct light
{
bool active;
float intensity;
vec3 position;
vec3 color;
};
</source>
Im Shader können dann neue Variablen von diesem Typ ganz einfach deklariert werden :
<source lang="glsl">
light LightSource[3];
</source>
Der Zugriff auf die Elemente der Struktur erfolgt dann wie gewohnt über den Punkt :
<source lang="glsl">
LightSource[i].position = vec3(1.0, 1.0, 5.0);
</source>

==Typenqualifzierer==

Zusätzlich zur Typendeklaration kann eine Variable noch einen Typenqualifizerer vorangestellt bekommen, der an den Anfang der Deklaration gehört.

* '''const'''
: Festgelegte (nur lesen) Konstante bzw. nur lesbarer Funktionsparameter.

* '''uniform'''
: Ein den ganzen Shader über gleichbleibender Wert, der eine Schnittstelle zwischen dem Shader und der OpenGL-Anwendung darstellt. Ein Uniformwert wird in der Hauptanwendung an den entsprechenden Shader übergeben und kann dort dann genutzt werden.

* '''attribute'''
: Nur lesbare Werte die eine Verbindung zwischen dem Shader und der OpenGL-VertexAPI darstellen (z.B. VertexParameter eines VertexArrays). Natürlich nur in einem Vertex Shader nutzbar.

* '''varying'''
: Stellt die Verbindung zwischen einem Vertex- und einem FragmentShader dar. Werden im VertexShader geschrieben und dann perspektivisch korrekt über die Primitive interpoliert, um dann im Fragment Shader gelesen werden zu können. Nutzbar sind hier nur die Typen float, vec2, vec3, vec4, mat2, mat3 und mat4, Strukturen und andere Datentypen können nicht varying sein. Die Namen einer varying-Variable müssen sowohl im VertexShader als auch im FragmentShader gleich sein.

* '''in'''
: Für Variablen die an eine Funktion übergeben und dort ausgelesen werden.

* '''out'''
: Für Variablen die von einer Funktion nach aussen zurückgegeben werden.

* '''inout'''
: Für Variablen die sowohl an eine Funktion übergeben als auch von dieser zurückgegeben werden.

Um obige Auflistung nicht leer im Raum stehen zu lassen zeige ich ein paar Beispiele die hoffentlich zum Verständnis beitragen :

===Beispiel A===
Vertexnormale soll an einen FragmenShader (interpoliert) übergeben werden :

:Im VertexShader :
<source lang="glsl">
varying vec3 VertexNormal;
...
VertexNormal = normalize(MV_IT * gl_Normal);
</source>
:Im FragmentShader :
<source lang="glsl">
varying vec3 VertexNormal;
...
TempVector = VertexNormal*...
</source>

===Beispiel B===
Uniformparameter zur nachträglichen Farbänderung der Szene wird im Programm übergeben :

:Im VertexShader :
<source lang="glsl">
uniform vec4 GlobalColor;
...
gl_FrontColor = GlobalColor * gl_Color;
</source>
:Im Programm :

glUniform4fARB(glSlang_GetUniLoc(ProgramObject, 'GlobalColor'), Col[0], Col[1], Col[2], Col[3]);

===Beispiel C===
Konstante zur festen Farbänderung :

:Im VertexShader :
<source lang="glsl">
const vec4 ColorBias = vec4(0.2, 0.3, 0.0, 0.0);
...
gl_FrontColor = ColorBias * gl_Color;
</source>
==Konstruktoren==

Um in einem Shader ''Vektoren'' oder ''Matrizen'' mit Werten zu belegen, gibt es sogenannte Konstruktoren (nicht zu verwechseln mit z.B. Klassenkonstruktoren unter Delphi), die im Endeffekt nichts anderes als Funktionen zur Vorbelegung von Vektoren oder Matrizen darstellen. Dabei trägt der Konstruktor den selben Namen wie die Typendeklaration, also lässt sich eine Variable vom Typ {{INLINE_CODE|vec4}} mit dem Konstruktor {{INLINE_CODE|vec4(float, float, float, float)}} initialisieren.

Allerdings hat man sich recht viel Mühe bei dieser Konstruktorgeschichte gemacht, so dass man einen vec4 nicht unbedingt mit einem {{INLINE_CODE|vec4}}-Konstruktor vorbelegen muss, sondern es vielseitige Möglichkeiten gibt. Um dies zu verdeutlichen gibts ein paar Beispiele :
<source lang="glsl">
vec4 Color = vec4(1.0, 0.0, 0.0, 0.0);
vec4 Color = vec4(MyVec3, 1.0);
vec4 Color = vec4(MyVec2_A, MyVec2_B);

vec3 LVec = vec3(MyVec4);
vec2 Tmp = vec2(MyVec3);
</source>

Trotz der recht wenigen Beispiele sollte schnell erkennbar sein, das man hier wirklich sehr viele Kombinationsmöglichkeiten hat, die dann gültig sind ''wenn man mindestens auf die benötigte Anzahl der Argumente kommt''. Im vorletzten Beispiel wird z.B. ein 3-Komponentenvektor aus einem 4-Komponentenvektor initialisiert. Das erzeugt keinen Fehler, sondern führt dazu das {{INLINE_CODE|vec3.x, vec3.y, vec3.z}} aus MyVec4 übernommen werden und MyVec4.w einfach ignoriert wird.

Das Umkehrbeispiel, also
<source lang="glsl">
vec4 Color = vec4(MyVec3)
</source>
funktioniert allerdings nicht, da hier die Zahl der benötigten Argumente nicht erreicht wird. In diesem Falle müsste es dann
<source lang="glsl">
vec4 Color = vec4(MyVec3, 0.0)
</source>
heissen.

Obiges gilt natürlich auch für ''Matrixkonstruktoren'', hier sind z.B. folgende Konstuktoren denkbar, obwohl eigentlich alle Möglichkeiten nutzbar sind, ''solange die benötigte Zahl an Argumenten erreicht wird'' :
<source lang="glsl">
mat4 MyMatrix = mat4(MyVec4, MyVec4, MyVec4, MyVec4);
mat2 MyMatrix = mat4(1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0);
</source>

==Vektor- und Matrixkomponenten==

Was natürlich in keiner Shadersprache fehlen darf, ist der leichte Zugriff auf die einzelnen Komponenten eines Vektors. glSlang bietet, je nach Anwendungsgebiet gleich drei Namensets für den Zugriff auf die Komponenten eines solchen Vektors, welches Set man nutzen will bleibt natürlich frei und ist unabhängig von der Deklaration eines Vektors. Man sollte nur darauf achten, beim gleichzeitigen Zugriff auf mehrere Komponenten im gleichen Namenset zu verbleiben :

* {x, y, z, w}
:Für den Zugriff auf Vektoren die Punkte, Normale oder sonstige Vertexdaten repräsentieren.

* {r, g, b, a}
:Für den Zugriff auf Vektoren die Farbwerte repräsentieren.

* {s, t, p, q}
:Für den Zugriff auf Vektoren die Texturkoordinaten repräsentieren.

Ein paar Beispiele zur Unterstreichung des oben gesagten :
<source lang="glsl">
v4.rgba = vec4(1.0, 0.0, 0.0, 0.0); // gültig
v4.rgzw = vec4(1.0, 1.0, 1.0, 2.0); // Ungültig, da verschiedenen Namensets
v2.rgb = vec3(1.0, 2.0, 1.0); // Ungültig, da vec2 nur r+g besitzt
v2.xx = vec2(5.0, 3.0); // Ungültig, da 2 mal gleiche Komponente
</source>

Auch der Zugriff auf die Komponenten einer Matrix geht leicht von der Hand. Namensets wie bei den Vektoren gibt es hier natürlich keine, aber folgende Beispiele sollen den Zugriff aufzeigen :
<source lang="glsl">
MyMat4[2] = vec4(1.0); // Setzt die 3.Zeile der Matrix komplett auf 1.0
MyMat4[3][3] = 3.5; // Setzt das Element unren rechts auf 3.5
</source>

Ein Zugriff auf Matrixelemente ausserhalb ihrer Dimension (also z.B. MyMat4[4][4]) liefert unvorhersehabre Ergebnise, also sollte man auf diese Fälle prüfen.

==Vektor- und Matrixoperationen==

Wie von C gewohnt sind in glSlang so ziemlich alle Operatoren die man auf Matrizen oder Vektoren anwenden kann überladen, so das man nicht umständlich über selbstgeschriebene Funktionen kombinieren muss. Darüber hinaus ist es in den meisten Fällen auch möglich ohne Konvertierung Fließkommawerte mit kompletten Matrizen oder Vektoren zu kombinieren. Folgende Beispiele zeigen einige der vielfältigen Kombinationsmöglichkeiten auf :
<source lang="glsl">
vec3 dest;
vec3 source;
float factor;

vec3 dest = source + factor;

// Ist gleich
dest.x = source.x + factor;
dest.y = source.y + factor;
dest.z = source.z + factor;
</source>

Matrix * Vektor ist auch ohne manuelle Konvertierung möglich :
<source lang="glsl">
vec3 dest;
vec3 source;
mat3 MyMat;

dest = source * MyMat;

// Ist gleich
dest.x = dot(source, MyMat[0]);
dest.y = dot(source, MyMat[1]);
dest.z = dot(source, MyMat[2]);
</source>

Auch hier sind die Möglichkeiten fast unbeschränkt und zeigen wieder wie flexibel glSlang ausgelegt ist.

==Operatoren==

glSlang bietet (momentan) folgende Operatoren, die Liste ist nach ihrer Gewichtung sortiert (Anfang = höchste). Alle ''reservierten'' Operatoren werden erst in kommender Hardware/glSlang-Versionen nutzbar sein :

<div align="center">
{|{{Prettytable_B1}}
!Operatorklasse
!Operatoren
!Assoziation
|-
|Gruppering
|()
| -
|-
|Arrayindizierung<br>Funktionsaufrufe und Konstruktoren<br>Strukturfeldwahl und Swizzle<br>Postinkrement und -dekrement<br>
|[]<br>()<br>.<br>++ --
|Links n. Rechts
|-
|Prefixinkrement- und dekrement<br>Einheitlich (~ reserviert)
| ++ --<br> + - ~ !
|Rechts n. Links
|-
|Mulitplikation (% reserviert)
|* / %
|Links n. Rechts
|-
|Additiv
| + -
|Links n. Rechts
|-
|Bitweises Verschieben (reserviert)
|<< >>
|Links n. Rechts
|-
|Relation
|< > <= >=
|Links n. Rechts
|-
|Vergleich
|== !=
|Links n. Rechts
|-
|Bitweises AND (reserviert)
|&
|Links n. Rechts
|-
|Bitweises XOR (reserviert)
|^
|Links n. Rechts
|-
|Bitweises OR (reserviert)
| <nowiki>|</nowiki>
|Links n. Rechts
|-
|Logisches AND
|&&
|Links n. Rechts
|-
|Logisches XOR
|^^
|Links n. Rechts
|-
|Logisches OR
| <nowiki>||</nowiki>
|Links n. Rechts
|-
|Auswahl
|?:
|Rechts n. Links
|-
|Zuweisung<br>Arithmetrische Zuweisung<br>(Modulis, Shift und bitweise Op. reserviert)
|<nowiki>=</nowiki><br> <nowiki>+= -= *= /= %=</nowiki> <br> <nowiki><<= >>= &= ^= |=</nowiki>
|Rechts n. Links
|-
|Aufzählung
|,
|Links n. Rechts
|-
|}
</div>

==Funktionen==

Ein großer Vorteil von Hochsprachen ist u.A. die Möglichkeit oft genutzte Codeteile in Funktionen (bzw. auch Prozeduren unter Pascal) zu verpacken um so Flexibilität als auch Übersichtlichkeit zu steigern. Wer schonmal was in C geschrieben hat, der wird sich jetzt sicherlich kein Kopfzerbrechen machen müssen. Funktionen werden in glSlang genauso nach folgendem Prinzip deklariert :
<source lang="glsl">
RückgabeTyp FunktionsName(Typ0 Argument0, Typ1, Argument1, ... , TypN, ArgumentN)
{
return RückgabeWert;
}
</source>

Funktionen die ''nichts zurückgeben'' müssen mit dem RückgabeTyp {{INLINE_CODE|void}} deklariert werden, ausserdem entfällt dann logischerweise das {{INLINE_CODE|return}}. Falls die Funktion eines ihrere Argumente nach aussen übergeben soll, muss dieses Argument mit dem Typenqualifizierer out (Siehe Kapitel 4.2) versehen werden. ''Arrays'' können nur als Eingabeargumente übergeben werden und dürfen nich dimensioniert als Argument verwendet werden, sondern müssen mit leeren Klammern argumentiert werden.
Ein paar Beispiele :
<source lang="glsl">
void MeineFunktion(float EingabeWert; out float AusgabeWert)
{
AusgabeWert = EingabeWert*MyConstValue;
}
</source>

Diese Funktion gibt ''nichts'' zurück, aber gibt EingabeWert*MyConstValue im Ausgabeargument AusgabeWert nach aussen.
<source lang="glsl">
float MeineFunktion(float EingabeWert)
{
return EingabeWert*MyConstValue;
}
</source>

Bietet genau die selbe Funktionalität wie das Beispiel darüber. Allerdings wird hier der berechnete Wert als Ergebnis der Funktion zurückgeliefert.
<source lang="glsl">
float VektorSumme(float v[])
{
return v[0]+v[1]+v[2]+v[3];
}
</source>

Wie bereits gesagt darf ein Array als Argument keine Dimensionierung enthalten. Wenn man der Funktion also ein Array übergibt, sollte man vorher drauf achten das es entsprechend der in der Funktion genutzten Indizes dimensioniert wurde.

==if-Anweisung==

Selektion über eine if-Anweisung darf auch in keiner Hochsprache fehlen. Genauso wie in C oder Delphi erwartet auch hier die If-Anweisung einen boolschen Ausdruck (Wahr oder Falsch) und wird dann ausgeführt (wahr) bzw. verzweigt auf ein (wenn vorhanden) else (falsch). Verschachtelung ist wie erwartet auch möglich.

'''Hinweis : '''
Grafikkarten auf dem Stand des Shadermodells 2.0 (Radeon 9x00, Radeon X8x0, GeForceFX 5x00) unterstüzten im Fragmentshader kein Early-Out, was zur Folge hat das bei einer If-Anweisung immer alle Zweige ausgeführt werden. Am Ende wird dann aber nur ein Ergebnis geschrieben, die anderen verworfen. Auf solchen Karten bringen If-Anweisungen also im Normalfall keine Geschwindigkeitssteigerung, sondern oft eher das Gegenteil.
Neuere SM3.0-Karten (Radeon X1x00, GeForce6x00 und höher) ist dass nicht mehr der Fall, da hier dynamische Verzweigungen und auch Early-Out von der Hardware implementiert werden.

==Schleifen==

Auch Schleifen, ein wichtiges Konzept jeder Hochsprache haben ihren Weg in glSlang gefunden. Unterstützt werden folgende Schleifentypen :

* '''for'''-Schleife
<source lang="glsl">
for (Startausdruck; Durchlaufbedingung; Wiederholungsausdruck)
{
statement
}
</source>

* '''while'''-Schleife
<source lang="glsl">
while (Durchlaufbedingung)
{
statement
}
</source>

* '''do'''-while-Schleife
<source lang="glsl">
do
{
statement
}
while (Durchlaufbedingung)
</source>

'''Hinweis :''' Grafikkarten auf dem Stand des Shadermodells 2.0 (Radeon 9x00, Radeon X8x0, GeForceFX 5x00) unterstüzten Schleifen nicht in Hardware. Schleifen werden dann beim Kompilieren vom Treiber entrollt, wodurch natürlich Shader mit weitaus mehr Instruktionen als erwartet generiert werden. Von daher sollte man auf solchen Karten möglichst auf Schleifen verzichten, oder diese nur recht kurz halten. Bei SM3.0-Karten (Radeon X1x00, GeForce6x00 und höher) ist dass nicht mehr der Fall.

=Eingebaute Variablen, Attribute und Konstanten=
Nachdem wir uns nun lange genug mit den minderinterssanten Elementen der glSlang-Syntax beschäftigt haben, gehts jetzt endlich an die wirklich interessanten Dinge. Wie schon ARB_VP/ARB_FP bringt auch glSlang jede Menge eingabauter Variablen, Attribute und Konstanten mit, deren Aliase sie recht leicht identifizierbar machen (ganz im Gegensatz zum Indexgewusel bei den DX-Shadern).

==Variablen im Vertex Shader==
Exklusiv im Vertex Shader stehen die folgenden Variablen zur Verfügung :

* vec4 gl_Position muss geschrieben werden
:Dieser Variable '''muss''' im Vertexshader ein Wert zugewiesen werden, wird dies nicht getan ist das Ergebnis (sprich die Position des Vertex) undefiniert. Vorgesehen ist diese Variable für die ''homogene Position des Vertex'' und wird u.a. zum Clipping und Culling verwendet. Sie darf natürlich auch (mehrfach) geschrieben und ausgelesen werden.

* float gl_PointSize kann geschrieben werden
:Diese Variable wurde dazu vorgesehen um dort im VertexShader die Punktgröße in Pixeln hineinzuschreiben.

* vec4 gl_ClipVertex kann geschrieben werden
:Falls genutzt, sollten hier die Vertexkoordinaten die im Zusammenhang mit benutzerdefinierten Clippingplanes genutzt werden abgelegt werden. Wichtig ist, das gl_ClipVertex im selben Koordinatenraum wie die Clippingplane definiert ist.

==Attribute im Vertex Shader==

Folgende Attribute stehen nur im Vertex Shader zur Verfügung und '''können nur gelesen werden''' :

* vec4 gl_Color
: Farbwert des Vertex.
* vec4 gl_SecondaryColor
:Sekundärer Farbwert des Vertex.
* vec4 gl_Normal
:Normale des Vertex.
* vec4 gl_Vertex
:Koordinaten des Vertex;
* vec4 gl_MultiTexCoord0..7
:Texturkoordinaten auf Textureinheit 0..7.
* float gl_FogCoord
:Nebelkoordinate des Vertex.

==Variablen im Fragment Shader==

Im Fragment Shader sind folgende Variablen exklusiv nutzbar :

* vec4 gl_FragColor
: Speichert den Farbwert des Fragmentes, der von folgenden Funktionen der festen Pipeline genutzt wird. Wird dieser Variable nichts zugewiesen, so ist ihr Inhalt undefiniert und darauf aufbauende Ergebnisse ebenfalls.

* vec4 gl_FragData[0..15]
: Ersetzt gl_FragColor bei der Verwendung von multiplen Rendertargets.

* float gl_FragDepth
: Durch schreiben dieser Variable kann man den von der festen Funktionspipeline ermittelten Tiefenwert überspringen, der mit {{INLINE_CODE|gl_FragCoord.z}} ausgelesen werden kann. Wird dieser Wert nicht geschrieben, nutzen folgende Funktionen der Pipeline den vorher fest berechneten Wert.

* vec4 gl_FragCoord nur lesen
: In dieser Variable ist die Position des Fragmentes relativ zur Fensterposition im Format x,y,z,1/w abgelegt, wobei z den von der festen Funktionspipeline berechneten Tiefenwert enthält.

* bool gl_FrontFacing nur lesen
: Gibt an ob das Fragment zu einer nach vorne zeigenden Primitive gehört (=true).

Im Bezug auf {{INLINE_CODE|gl_FragColor}} und {{INLINE_CODE|gl_FragDepth}} sei noch anzumerken das diese ''nicht'' in den Wertebereich 0..1 gebracht werden müssen, da dies später durch die feste Funktionspipeline automatisch gemacht wird.

==Eingebaute Varyings==

Wie bereits in Kapitel 4.2 erwähnt, stellen Varyings eine Schnittstelle zwischen dem Vertex und dem Fragment Shader dar. Sie werden im Vertex Shader geschrieben und können dann im Fragment Shader ausgelesen werden, ohne das die folgenden Varyings dafür explizit deklariert werden müssen :

* vec4 gl_FrontColor
: Farbe der Vorderseite des Vertex.

* vec4 gl_BackColor
: Farbe der Rückseite des Vertex.

* vec4 gl_FrontSecondaryColor
: Sekundäre Farbe der Vorderseite des Vertex.

* vec4 gl_BackSecondaryColor
: Sekundäre Farbe der Rückseite des Vertex.

* vec4 gl_TexCoord[x]
: Texturkoordinaten des Vertex auf Textureinheit x, wobei x die von der Hardware zur Verfügung gestellte Zahl der Textureinheiten-1 nicht überschreiten darf.

* float gl_FogFragCoord
: Nebelkoordinate des Fragmentes.

Die Varyings {{INLINE_CODE|gl_FrontColor, gl_FrontSecondaryColor, gl_BackColor}} und {{INLINE_CODE|gl_BackSecondaryColor}} können im FragmentShader nur unter den Aliases gl_Color bzw. gl_SecondaryColor gelesen werden. Welcher Wert des Vertex Shaders im Fragment Shader dort eingesetzt wird ist abhängig davon ob das Fragment zu einer nach vorne oder nach hinten zeigenden Primitive gehört.

==Eingebaute Konstanten==
Auch diverse Konstanten wurden definiert um darauf schnell im Shader zugreifen zu können. In den Klammern stehen die von einer GL-Implementation als Mindestanforderung anzubietenden Werte. Alle Konstanten sind sowohl im Vertex als auch im Fragment Shader abrufbar :

: OpenGL 1.0/1.2 :
* int gl_MaxLights (8)
* int gl_MaxClipPlanes (6)
* int gl_MaxTextureUnits (2)

: ARB_Fragment_Program :
* int gl_MaxTextureCoordsARB (2)

: Vertex_Shader :
* int gl_MaxVertexAttributesGL2 (16)
* int gl_MaxVertexUniformFloatsGL2 (512)
* int gl_MaxVaryingFloatsGL2 (32)
* int gl_MaxVertexTextureUnitsGL2 (1)

: Fragment_Shader :
* int gl_MaxFragmentTextureUnitsGL2 (2)
* int gl_MaxFragmentUniformFloatsGL2 (64)

==Eingebaute Uniformvariablen==

Um den Zugriff auf OpenGL-Staten zu vereinfachen wurden in glSlang diverse Uniformvariablen zur direkten Verwendung im Shader eingebaut. Wie gewohnt wurden auch hier sinnvolle Namen verwendet, so dass eine tiefere Erklärung unnötig sein dürfte :

* mat4 gl_ModelViewMatrix
* mat4 gl_ProjectionMatrix
* mat4 gl_ModelViewProjectionMatrix
* mat3 gl_NormalMatrix
:{{INLINE_CODE|gl_NormalMatrix}} repräsentiert die invertierten und anschließend transponierten oberen 3x3 Werte der {{INLINE_CODE|gl_ModelViewMatrix}}.
* mat4 gl_TextureMatrix[gl_MaxTextureCoordsARB]

* float gl_NormalScale
: Gibt den unter OpenGL festgelegten Faktor zur Skalierung der Normalen zurück.

* struct gl_DepthRangeParameters
<source lang="glsl">
struct gl_DepthRangeParameters
{
float near;
float far;
float diff;
};
gl_DepthRangeParameters gl_DepthRange;
</source>
: Clippingplanes :
* vec4 gl_ClipPlane[gl_MaxClipPlanes]

*struct gl_PointParameters
<source lang="glsl">
struct gl_PointParameters
{
float size;
float sizeMin;
float sizeMax;
float fadeThresholdSize;
float distanceConstantAttenuation;
float distanceLinearAttenuation;
float distanceQuadraticAttenuation;
};
gl_PointParameters gl_Point;
</source>
*struct gl_MaterialParameters
<source lang="glsl">
struct gl_MaterialParameters
{
vec4 emission;
vec4 ambient;
vec4 diffuse;
vec4 specular;
float shininess;
};
gl_MaterialParameters gl_FrontMaterial;
gl_MaterialParameters gl_BackMaterial;
</source>
*struct gl_LightSourceParameters
<source lang="glsl">
struct gl_LightSourceParameters
{
vec4 ambient;
vec4 diffuse;
vec4 specular;
vec4 position;
vec4 halfVector;
vec3 spotDirection;
float spotExponent;
float spotCutoff;
float spotCosCutoff;
float constantAttenuation;
float linearAttenuation;
float quadraticAttenuation;
};
gl_LightSourceParameters gl_LightSource[gl_MaxLights];
</source>
*struct gl_LightModelParameters
<source lang="glsl">
struct gl_LightModelParameters
{
vec4 ambient;
};
gl_LightModelParameters gl_LightModel;
</source>
*struct gl_LightModelProducts
<source lang="glsl">
struct gl_LightModelProducts
{
vec4 sceneColor;
};
gl_LightModelProducts gl_FrontLightModelProduct;
gl_LightModelProducts gl_BackLightModelProduct;
</source>
*struct gl_LightProducts
<source lang="glsl">
struct gl_LightProducts
{
vec4 ambient;
vec4 diffuse;
vec4 specular;
};
gl_LightProducts gl_FrontLightProduct[gl_MaxLights];
gl_LightProducts gl_BackLightProduct[gl_MaxLights];
</source>
* vec4 gl_TextureEnvColor[gl_MaxFragmentTextureUnitsGL2]
* vec4 gl_EyePlaneS[gl_MaxTextureCoordsARB]
* vec4 gl_EyePlaneT[gl_MaxTextureCoordsARB]
* vec4 gl_EyePlaneR[gl_MaxTextureCoordsARB]
* vec4 gl_EyePlaneQ[gl_MaxTextureCoordsARB]
* vec4 gl_ObjectPlaneS[gl_MaxTextureCoordsARB]
* vec4 gl_ObjectPlaneT[gl_MaxTextureCoordsARB]
* vec4 gl_ObjectPlaneR[gl_MaxTextureCoordsARB]
* vec4 gl_ObjectPlaneQ[gl_MaxTextureCoordsARB]

*struct gl_FogParameters
<source lang="glsl">
struct gl_FogParameters
{
vec4 color;
float density;
float start;
float end;
float scale;
};
gl_FogParameters gl_Fog;
</source>
Diese recht umfangreiche GL-Stateliste sollte eigentlich jeden Bedarf decken und momentan gibts kaum einen OpenGL-Status den man so nicht in einem Shader abfragen bzw. nutzen kann.

=Eingebaute Funktionen=
glSlang ist mit diversen Skalar- und Vektorfunktionen ausgestattet, die teilweise (idealerweise) sogar direkt in der Hardware ausgeführt werden, weshalb einer fertigen Funktion ggü. gleichwertigen eigenen Berechnungen immer der Vorzug zu geben ist.
{{Hinweis| ''genType'' kann vom Type float, vec2, vec3 oder vec4 sein, ''mat'' vom Typ mat2, mat3 oder mat4.}}

==Trigonometrie und Winkel==
Alle übergebenen Winkel sollten, soweit nicht anders vermerkt, in Radien angegeben werden.

* genType radians (genType degrees)
: Wandelt von Grad nach Radien.
* genType degrees (genType radians)
: Wandelt von Radien nach Grad.
* genType sin (genType angle)
: Gibt den Sinus von Angle zurück, wobei Angle in Radien angegeben wird.
* genType cos (genType angle)
: Gibt den Cosinus von Angle zurück, wobei Angle in Radien angegeben wird.
* genType tan (genType angle)
: Gibt den Tangens von Angle zurück, wobei Angle in Radien angegeben wird.
* genType asin (genType x)
: Liefert den Arcsinus von x zurück, also den Winkel dessen Sinus x ergeben würde.
* genType acos (genType x)
: Liefert den Arccosinus von x zurück, also den Winkel dessen Cosinus x ergeben würde.
* genType atan (genType y, genType x)
: Liefert den Winkel zurück, dessen Tangens x/y ergeben würde.
* genType atan (genType y_over_x)
: Liefert den Winkel zurück, dessen Tangens x über y ergeben würde.

==Exponentiell==
* genType pow (genType x, genType y)
: Gibt x hoch y zurück.
* genType exp2 (genType x)
: Gibt 2 hoch x zurück.
* genType log2 (genType x)
: Gibt den Logarithmus zur Basis 2 von x zurück.
* genType sqrt (genType x)
: Gibt die Wurzel von x zurück.
* genType inversesqrt (genType x)
: Gibt die umgekehrte Wurzel von x zurück.

==Standardfunktionen==
* genType abs (genType x)
: Liefert den absoluten Wert von x zurück.
* genType sign (genType x)
: Gibt -1.0 zurück, wenn x < 0.0, 0.0 wenn x = 0.0 und 1.0 wenn x > 0.0.
* genType floor (genType x)
: Gibt denn nächsten Integerwert zurück, der kleiner oder gleich x ist.
* genType ceil (genType x)
: Gibt den nächsten Integerwert zurück, der größer oder gleich x ist.
* genType fract (genType x)
: Gibt den Nachkommateil von x zurück.
* genType mod (genType x, float y)
* genType mod (genType x, genType y)
: Gibt den Modulus zurück. (=x-y * floor(x/y))
* genType min (genType x, genType y)
* genType min (genType x, float y)
: Liefert y zurück wenn y < x, ansonsten x.
* genType max (genType x, genType y)
* genType max (genType x, float y)
: Liefert y zurück wenn x < y, ansonsten x.
* genType clamp (genType x, genType minVal, genType maxVal)
* genType clamp (genType x, float minVal, float maxVal)
: Zwängt x in den Bereich minVal..maxVal.
* genType mix (genType x, genType y, genType a)
* genType mix (genType x, genType y, float a)
: Liefert den linearen Blend zwischen x und y zurück. (= x * (1-a) + y * a)
* genType step (genType edge, genType x)
* genType step (float edge, genType x)
: Liefert 0.0 zurück, wenn x <= edge, ansonsten 1.0.
* genType smoothstep (genType edge0, genType edge1, genType x)
* genType smoothstep (float edge0, float edge1, genType x)
: Liefert 0.0 zurück, wenn x <= edge und 1.0 wenn x >= edge. Dabei wird eine weiche Hermite Interpolation zwischen 0 und 1 durchgeführt.

==Geometrie==
* float length (genType x)
: Gibt die Länge des Vektors x (= sqrt(x[0]² + x[1]² + ... + x[n]²) zurück.
* float distance (genType p0, genType p1)
: Gibt die Distanz zwischen den zwei Vektoren p0 un p1 (= length(p0-p1)) zurück.
* float dot (genType x, genType y)
: Gibt das Punktprodukt von x und y zurück (=x[0]*y[0] + x[1]*y[1] + ... + x[n]*y[n]).
* vec3 cross (vec3 x, vec3 y)
: Gibt das Kreuzprodukt von x und y zurück.
* genType normalize (genType x)
: Normalisiert den Vektor x auf die Länge 1.
* vec4 ftransform()
: Nur im Vertex Shader. Die Funktion stellt sicher, das das eingehende Vertex haargenau so transformiert wird wie in der festen Funktionspipeline. gl_Position = ftransform() wird dann also gebraucht, wenn in mehreren Durchgängen sowohl im Shader als auch in der festen Pipeline gerendert wird, um sicherzustellen das in beiden Fällen die gleiche Vertexposition herauskommt.
* genType faceforward (genType N, genType I, genType Nref)
: Gibt einen nach vorne zeigenden Vektor N zurück. (If dot(NRef, I) < 0 return N else return -N)
* genType reflect (genType I, genType N)
: Gibt den an der Flächenausrichtung N reflektierten Vektor I zurück. (=I-2 * dot(N,I) * N)

==Matrixfunktionen==
* mat matrixCompMult (mat x, mat y)
: Multipliziert Matrix X mit Matrix Y komponentenweise. Um eine normale lineare Matrixmultiplikation durchzuführen, sollte der "*"-Operator genutzt werden.

==Vektorvergleiche==
Die meisten Vektorvergleichsfunktionen liefern als Ergebnis einen boolvektor zurück, da die Vergleiche per Komponente stattfinden. Wenn man also x = vec4(1.0, 3.0, 0.0, 0.0) mit y = vec4(2.0, 1.5, 1.5, 0.0) via lessThan(x, y) vergleicht, erhält man als Ergebnis bvec(true, false, true, false).

* bvec lessThan (vec x, vec y)
* bvec lessThan (ivec x, ivec y)
: Gibt den komponentenweisen Vergleich x < y zurück.
* bvec lessThanEqual (vec x, vec y)
* bvec lessThanEqual (ivec x, ivec y)
: Gibt den komponentenweisen Vergleich x <= y zurück.
* bvec greaterThan (vec x, vec y)
* bvec greaterThan (ivec x, ivec y)
: Gibt den komponentenweisen Vergleich x > y zurück.
* bvec greaterThanEqual (vec x, vec y)
* bvec greaterThanEqual (ivec x, ivec y)
: Gibt den komponentenweisen Vergleich x >= y zurück.
* bvec equal (vec x, vec y)
* bvec equal (ivec x, ivec y)
* bvec equal (bvec x, bvec y)
: Gibt den komponentenweisen Vergleich x == y zurück.
* bvec notEqual (vec x, vec y)
* bvec notEqual (ivec x, ivec y)
* bvec notEqual (bvec x, bvec y)
: Gibt den komponentenweisen Vergleich x != y zurück.
* bool any (bvec x)
: Liefert true zurück, wenn mindestens eine der Komponenten von x true ist.
* bool all (bvec x)
: Liefert true zurück, wenn alle Komponenten von x true sind.
* bvec not (bvec x)
: Liefert die logische Negation von x zurück.

==Texturenzugriffe==

Diese wichtige Funktionskategorie dient dazu, Werte aus einer an eine Textureinheit gebundenen Textur zu ermitteln. Die Texturenzugriffe können sowohl im Vertex (!) als auch im Fragment Shader ausgeführt werden, wobei der optionale Parameter bias im Vertex Shader ignoriert wird. Allerdings gibt es zusätzlich Funktionen die auf "Lod" enden und nur im Vertex Shader genutzt werden dürfen um eben dieses Manko zu umgehen. Funktionen mit dem Suffix "Proj" geben einen projizierten Texturenwert zurück.

: '''1D-Texturen :'''
* vec4 texture1D (sampler1D sampler, float coord [, float bias])
* vec4 texture1DProj (sampler1D sampler, vec2 coord [, float bias])
* vec4 texture1DProj (sampler1D sampler, vec4 coord [, float bias])
: Nur im Vertex Shader :
* vec4 texture1DLod (sampler1D sampler, float coord, float lod)
* vec4 texture1DProjLod (sampler1D sampler, vec2 coord, float lod)
* vec4 texture1DProjLod (sampler1D sampler, vec4 coord, float lod)

: '''2D-Texturen :'''
* vec4 texture2D (sampler2D sampler, vec2 coord [, float bias])
* vec4 texture2DProj (sampler2D sampler, vec3 coord [, float bias])
* vec4 texture2DProj (sampler2D sampler, vec4 coord [, float bias])
: Nur im Vertex Shader :
* vec4 texture2DLod (sampler2D sampler, vec2 coord, float lod)
* vec4 texture2DProjLod (sampler2D sampler, vec3 coord, float lod)
* vec4 texture2DProjLod (sampler2D sampler, vec4 coord, float lod)

: '''3D-Texturen :'''
* vec4 texture3D (sampler3D sampler, vec3 coord [, float bias])
* vec4 texture3DProj (sampler3D sampler, vec4 coord [, float bias])
: Nur im Vertex Shader :
* vec4 texture3DLod (sampler3D sampler, vec3 coord, float lod)
* vec4 texture3DProjLod (sampler3D sampler, vec4 coord, float lod)

: '''Cubemap :'''
* vec4 textureCube (samplerCube sampler, vec3 coord [, float bias])
: Nur im Vertex Shader :
*vec4 textureCubeLod (samplerCube sampler, vec3 coord, float lod)

: '''Tiefentextur (Shadowmap) :'''
* vec4 shadow1D (sampler1DShadow sampler, vec3 coord [, float bias])
* vec4 shadow2D (sampler2DShadow sampler, vec3 coord [, float bias])
* vec4 shadow1DProj (sampler1DShadow sampler, vec4 coord [, float bias])
* vec4 shadow2DProj (sampler2DShadow sampler, vec4 coord [, float bias])
: Nur im Vertex Shader :
* vec4 shadow1DLod (sampler1DShadow sampler, vec3 coord, float lod)
* vec4 shadow2DLod (sampler2DShadow sampler, vec3 coord, float lod)
* vec4 shadow1DProjLod (sampler1DShadow sampler, vec4 coord, float lod)
* vec4 shadow2DProjLod (sampler2DShadow sampler, vec4 coord, float lod)

Wie bereits eingangs gesagt ist dieses Kapitel ein sehr wichtiges, denn eine 3D-Szene ohne Texturen ist heute kaum denkbar. Darüber hinaus lassen sich durch Texturenzugriffe recht viele interessante Sachen machen, z.B. ein einfacher Blurfilter oder das freie überblenden bestimmter Texturenteile. Deshalb führe ich hier kurz ein paar Beispiele an, welche die Nutzung dieser Funktionen verdeutlichen sollen :

===Beispiel A===
Eine Textur gebunden die einfach ausgegeben werden soll

''Im Vertex Shader'' :
<source lang="glsl">
void main(void)
{
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
gl_TexCoord[0] = gl_MultiTexCoord0;
}
</source>
Der Vertex Shader ist recht minimal. Neben der homogenen Vertexposition leiten wir hier nur die im OpenGL-Programm angegebenen Texturkoordinaten weiter. ''Dies ist aber unbedingt nötig!'' Ohne die letzte Zeile hätten wir im Fragment Shader keine gültigen Texturkoordinaten auf TMU0, was in einer Fehldarstellung enden würde.

''im Fragment Shader'' :
<source lang="glsl">
uniform sampler2D texSampler;

void main(void)
{
gl_FragColor = texture2D(texSampler, vec2(gl_TexCoord[0]));
}
</source>
Zuerst deklarieren wir hier einen 2D-Texturensampler, wichtig : '''Texturensampler müssen IMMER als uniform deklariert werden!''' In der Hauptfunktion weisen wir dann einfach den über die Funktion texture2D aus unserer gebundenen Textur ausgelesenen Farbwert, anhand der vom Vertex Shader übergebenen Texturkoordinaten, zu.

===Beispiel B===
Zwei Texturen, jeweils auf TMU0 und TMU1. Fragmentfarbe soll eine Multiplikation der beiden Texturen darstellen.

In diesem Beispielfall (der recht häufig vorkommt) müssen wir im Programm festlegen, ''welcher Sampler welche Textureinheit adressiert'', genau deshalb müssen die Texturensampler auch als uniform deklariert werden. Die Standardtextureneinheit eines Samplers ist TMU0, was in unserem Falle natürlich nicht brauchbar ist. Also müssen wir unserem zweiten Textursampler im Programm mitteilen das er seine Daten aus TMU1 beziehen soll :

glUniform1iARB(glSlang_GetUniLoc(ProgramObject, 'texSamplerTMU1'), 1);

Dies ist also unbedingt zu machen, sobald ein Texturensampler eine Textureinheit > GL_TEXTURE_0 adressieren will. Die Textureneinheit des Samplers lässt sich also nicht im Shader selbst festlegen. Der Fragment Shader ist nun allerdings schnell hergeleitet (Vertex Shader verändert sich nicht, da TMU1 die Texturkoordinaten auch von TMU0 bezieht) :

im Fragment Shader :
<source lang="glsl">
uniform sampler2D texSamplerTMU0;
uniform sampler2D texSamplerTMU1;

void main(void)
{
gl_FragColor = texture2D(texSamplerTMU0, vec2(gl_TexCoord[0])) *
texture2D(texSamplerTMU1, vec2(gl_TexCoord[0]));
}
</source>

==Noisefunktionen==
Sowohl im Vertex als auch im Fragment Shader lassen sich [[GLSL noise|Noisefunktionen]] nutzen, mit deren Hilfe sich eine gewisse "Zufälligkeit" simulieren lässt (wirklich zufällige Werte sind es natürlich nicht). Ein zurückgegebener Wert liegt dabei immer im Bereich [-1..1] und ist immer bei gleichem Eigabewert auch immer gleich. Die Verwendung empfiehlt sich derzeit allerdings eher nicht, da nicht alle aktuellen Treiber die Funktionen unterstützen und eine Noisetextur wahrscheinlich performanter ist.

* float noise1 (genType x)
* vec2 noise2 (genType x)
* vec3 noise3 (genType x)
* vec4 noise4 (genType x)

==Discard==
Eigentlich keine Funktion, sondern eine Abbruchbedingung '''nur im Fragment Shader'''. Das Schlüsselwort {{INLINE_CODE|discard}} verwirft das aktuell bearbeitete Fragment und beendet gleichzeitig den Shader. Es kann z.B. genutzt werden um Alphamasking manuell durchzuführen.
Man sollte dabei jedoch beachten dass ein Großteil der aktuellen Hardware kein "early-out" (frühes Beenden) im Fragmentshader unterstützt. Wenn dort also ein {{INLINE_CODE|discard}} auftaucht, wird trotzdem auch der Code danach ausgeführt und einfach verworfen. Einen Geschwindigkeitsvorteil durch diesen Befehl wird man also erst auf neueren Karten feststellen, die dieses Faeature auch so unterstützen wie es angedacht war.

=Beispielshader=
Wen bis hierhin nicht der Mut verlassen hat, und wer aufmerksam gelesen hat, dürfte jetzt also zumindest in der Lage sein kleinere Shader in glSlang zu schreiben und diese auch im Programm zu nutzen. Ich habe im Themenbereich "glSlang" versucht alle Bereiche der Shadersprache selbst anzusprechen und hoffe das auch brauchbar rübergebracht zu haben. Um oben erlerntes (hoffe ich doch mal) nochmal zu vertiefen werde ich jetzt (wie ich das bereits bei meinem ARB_VP-Tutorial getan habe) einen simplen Beispielshader (Vertex und Fragment Shader) auseinanderpflücken um so u.a. auch die Programmstruktur für alle die in C nicht so bewandert sind zu erörtern.

==Der Vertex Shader==
<source lang="glsl">
uniform vec4 GlobalColor;

void main(void)
{
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
gl_FrontColor = gl_Color * GlobalColor;
gl_TexCoord[0] = gl_MultiTexCoord0;
}
</source>

Wie gesagt recht simpel. Angefangen wird mit der Deklaration einer globalen Uniformvariable namens {{INLINE_CODE|GlobalColor}}. Wie wir uns erinnern gibt der Typenqualifizierer uniform an, das wir den Wert dieser Variable (ein 4-Komponentenvektor, da Farbwerte aus R,G,B und A bestehen) in unserem Programm an den Shader übermitteln.

Danach gehts ohne Umwege direkt in unsere Hauptfunktion, da wir im Vertex Shader keine anderen Funktionen benötigen. Dort berechnen wir zuerst die homogene Position unseres Vertex, die sich aus der eingehenden Vertexposition multipliziert mit der Modelansichtsmatrix ergibt. Wie schonmal gesagt '''muss diesem Wert etwas zugewiesen werden''', da sonst alle darauf aufbauenden Funktionen unvorhersehbare Ergebnisse liefern.
Ausserdem wollen wir die Frontfarbe unseres Vertex jedesmal mit der im Programm übergebenen GlobalColor multiplizieren, so dass wir den Farbwert der gesamten Szene aus unserem Programm heraus manipulieren können. Zu guterletzt geben wir dann noch unsere aus der festen Funktionspipeline erhaltenen Texturkoordinaten auf Textureinheit 0 weiter. Wenn im Fragmentshader Texturkoordinaten verwendet werden, '''muss das getan werden'''.

==Der Fragment Shader==
<source lang="glsl">
uniform sampler2D Texture0;
uniform sampler2D Texture1;
uniform sampler2D Texture2;
uniform sampler2D Texture3;

void main(void)
{
vec2 TexCoord = vec2( gl_TexCoord[0] );
vec4 RGB = texture2D( Texture0, TexCoord );

gl_FragColor = texture2D(Texture1, TexCoord) * RGB.r +
texture2D(Texture2, TexCoord) * RGB.g +
texture2D(Texture3, TexCoord) * RGB.b;
}
</source>

Auch hier passiert nicht wirklich viel Großartiges. Wir deklarieren beim Shaderanfang zuerst vier Texturensampler, da wir insgesamt vier verschiedene Texturen im Shader auslesen wollen, eine Verlaufstextur und drei Oberflächentexturen. Auch hier sei wieder gesagt das man Sampler '''immer als uniform deklarieren muss'''. In der Hauptfunktion deklarieren wir dann einen Farbvektor, der auch direkt einen Farbwert aus Textureinheit 0 zugewiesen bekommt. Auf Textureinheit 0 haben wir ihm Hauptprogramm eine Verlaufstextur gebunden, die angibt wie die drei folgenden Texturen ineinander geblendet werden.
Danach schreiben wir dann den Farbwert des Fragmentes, der '''im Fragment Shader ausgegeben werden muss'''. Der besteht wie einfach zu erkennen aus Farbwert von Textureinheit 1 * Rotwert von Textureinheit 0 + Farbwert von Textureinheit 2 * Grünwert von Textureinheit 0 + Farbwert von Textureinheit 3 * Blauwert von Textureinheit 0. So ist z.B. an Stellen an denen in der Verlaufstextur reines blau liegt nur die dritte Textur sichtbar.

So viel also zu unserem kleinen Beispielshader. Er ist weder besonders toll noch besonders sinnvoll, sollte aber auch eher dazu dienen euch glSlang ein wenig zu veranschaulichen, was mir hoffentlich gelungen ist.

Wenn ihr in den vorangegangenen Kapiteln zumindest ein wenig aufgepasst habt, dann könnt ihr euch vor eurem inneren Auge hoffentlich vortstellen was der Shader macht : Er blendet drei Texturen weich anhand der Verlaufstextur ineinander über. Sowas kann man z.B. für ein Terrain nutzen, um dieses anhand einer Farbtextur zu texturieren. Für alle, die damit Probleme haben hier zwei Bilder die den Shader veranschaulichen. Links die Verlaufstextur, die angibt wo welche Textur wie stark gewichtet wird und rechts dann das Ergebnis :

<div align="center"> [[BILD:GLSL_sample_shader_a.jpg]] [[BILD:GLSL_sample_shader_b.jpg]]</div>

=Post Mortem=
Das wars also, meine "Einführung" in die OpenGL Shader Sprache. Ich hoffe es hat euch nicht gelangweilt und auch die von mir zur Verfügung gestellten Informationen haben euch hoffentlich ausgereicht. Mit der Veröffentlichung dieser Einführung geht übrigens auch die Eröffnung eines Shaderforums hier auf der DGL einher, in der ihr dann also fleissig Fragen zum Thema stellen oder eure Shader präsentieren könnt. In diesem Post Mortem gehe ich jetzt noch kurz auf die Zukunft von glSlang ein und zeige ein paar Screenshots (damit die Augen entspannen können), bevor ihr euch dann selbst in die Shaderwelt stürzen könnt.

=Beispiele=

Anbei ein paar exemplarische Screenshots. Da man mit GLSL aber alle möglichen Effekte berechnen kann (u.a. auch 1:1 die feste Funktionspipeline) ist es hier unmöglich einen Überblick aller möglichen Techniken zu geben.

[[Datei:tut_glsl_eigenershader_01.png]] [[Datei:tut_glsl_eigenershader_02.png]] [[Datei:tut_glsl_eigenershader_03.png]]

Wie im ersten (und dritten) Screenshot zu sehen ist es natürlich auch möglich mehrere Techniken innerhalb einer Szene zu nutzen. Hier sind letztendlich bis auf Hardwarelimitationen keine Grenzen gesetzt.

=Die Zukunft=
Als dieses Tutorial geschrieben wurde, war noch nicht ganz abzusehen dass bzw. ob sich GLSL auch durchsetzen würde. ARB-Shadr und NVidias cG waren damals die Platzhirsche, aber inzwischen werden ARB-Shader nicht mehr genutzt (und auch schon länger nicht mehr weiterentwickelt) und auch NVidia setzt primär auf GLSL. GLSL wird permanent weiterenwtickelt und Hersteller können dank des flexiblen Extensionsystems auch in GLSL eigene Extensions offenlegen um die aktuellsten Features (wie z.b. den Tesselator auf aktuellen ATI-Karten) nutzen zu können. GLSL it als inzwischen auch offizielle die Shadersprache frü OpenGL und wird permanent an die neusten technischen Entwicklungen im Grafikkartenbereich angepasst.

Wer also unter OpenGL etwas mit Shadern machen möchte, kommt an GLSL nicht vorbei!

Also viel Spaß beim Experimentieren und Shaderschreiben! Und nicht vergessen : Wir wollen sehen was ihr so treibt,

Euer
:Sascha Willems

{{TUTORIAL_NAVIGATION|-|[[Tutorial_glsl2]]}}
[[Kategorie:Tutorial|GLSL]]

Link

2011-08-13T17:58:53Z

Lord horazont: /* Texturen */ Ticks und Crosses

Diese Linksammlung soll allgemeine Links zu unterschiedlichen Themen bieten, die mit der Multimediaentwicklung zu tun haben.
{{Hinweis|Vielleicht ist eine Zusammenführung mit [[Tool]] sinnvoll!}}
{{Hinweis|Vielleicht ist eine Aufteilung in Unterseiten sinnvoll (möglicherweise mit Kategorien)}}

= Entwicklung mit OpenGL =

== Hardwareinfos ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://delphi3d.net/hardware/listreports.php OpenGL Hardware Registry - Hardwareübersicht]
|{{Englisch}}
|Eine Datenbank aller Grafikkarten die in der Harware Registry vorhanden sind. Die einzelnen Artikel enthalten Infos darüber, welche Extensions von der Grafikkarte unterstützt werden.
|-
|[http://delphi3d.net/hardware/allexts.php OpenGL Hardware Registry - Extensionübersicht]
|{{Englisch}}
|Eine Datenbank aller Extensions die in der Harware Registry vorhanden sind. Die einzelnen Artikel enthalten Infos darüber, welche Grafikkarten die entsprechende Extension unterstützen.
|-
|}

== Tutorials ==

{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
||[[Tutorial|DGL Wiki - Tutorial]]
|{{Deutsch}}
|DelphiGL.com ist Betreiber dieses Wikis und stellt eine Vielzahl Tutorials mit Schwehrpunkt OpenGL zur Verfügung.
Neben Tutorials für Einsteiger und OpenGL Anfänger gibt es auch fortgeschrittene Themen wie Shader oder Partikelsysteme.Sprache der Wahl ist hier Delphi.
|-
|[http://www.joachimrohde.com/cms/xoops/modules/articles/index.php?cat_id=1 joachimrohde.com]
|{{Deutsch}}
|Auf dieser Seite findet ihr deutsche Übersetzungen der bekannten NeHe Tutorials. Sprache der Wahl ist hier C++.
|-
|[http://www.cg.tuwien.ac.at/studentwork/VRSem96/OpenGL/ Technische Universität Wien]
|{{Deutsch}}
|
|-
|[http://nehe.gamedev.net/ Nehe]
|{{Englisch}}
|Die berühmt berüchtigten NeHe Tutorials sind eine umfangreiche Sammlung an Tutorials zum Thema OpenGL. Von Anfängertutorials bis hin zu komplexen Effekten wird alles behandelt. Sprache der Wahl ist hier C++. (Eine Übersetzung der NeHe Tutorials findet ihr bei Joachim Rhode (siehe oben). )
|-
|[http://www.sulaco.co.za/tut.htm sulaco.co.za]
|{{Englisch}}
| OpenGL Beispiele in Delphi
|}

== OpenGL Funktionen ==

=== GL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GL|DGL Wiki - Kategorie GL]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten OpenGL Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL.tar.gz OpenGL.org - Orginal Spezifkationen]
|{{Englisch}}
|Die Orginalspezifikationen der OpenGL 1.0 und OpenGL 1.1 Befehle. (Diese HTML-Dokumente sind nicht Copy&Paste freundlich, da sie vermutlich automatisch aus vorhandenen Dateien (Postscript) erzeugt wurden.)
|-
|[http://developer.3dlabs.com/documents/glmanpage_index.htm 3dLabs]
|{{Englisch}}
|Die Orginalspezifikationen der OpenGL 1.0 und OpenGL 1.1 Befehle.
|-
|[http://www.mevis.de/~uwe/opengl/opengl.html mevis.de]
|{{Englisch}}
|Sammlung von Englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|[http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/glfunc01_4f03.asp MSDN von Microsoft]
|{{Englisch}}
|OpenGL Dokumentation in der MSDN. Die Erklärung der MSDN sind meist keine reinen Kopien der Orginalspezifikationen, sondern enthalten hin und wieder auch zusätzliche Informationen, oder formulieren Texte auf verständlichere Art und Weise.
|-
|}

=== GLU ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GLU|DGL Wiki - Kategorie GLU]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten GLU Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/glu/ OpenGL.org - Orginal Spezifkationen]
|{{Englisch}}
|Orginalspezifikationen für die GLU Befehle. (Diese HTML-Dokumente sind nicht Copy&Paste freundlich, da sie vermutlich automatisch aus vorhandenen Dateien (Postscript) erzeugt wurden.)
|-
|[http://www.mevis.de/~uwe/opengl/opengl.html mevis.de]
|{{Englisch}}
|Sammlung von englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|[http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/glufnc01_0e43.asp MSDN von Microsoft]
|{{Englisch}}
|GLU Dokumentation in der MSDN. Die Erklärung der MSDN sind meist keine reinen Kopien der Orginalspezifikationen, sondern enthalten hin und wieder auch zusätzliche Informationen, oder formulieren Texte auf verständlichere Art und Weise.
|-
|}

=== GLX ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GLX|DGL Wiki - Kategorie GLX]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten GLX Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/glx/ OpenGL.org - Orginal Spezifkationen]
|{{Englisch}}
|Orgninalspezifikationen der GLX Befehle bei OpenGL.org.
|-
|[http://www.mevis.de/~uwe/opengl/opengl.html mevis.de]
|{{Englisch}}
|Sammlung von Englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|}

=== WGL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:WGL|DGL Wiki - Kategorie WGL]]
|{{Deutsch}}
|Wiki-Kategorie die alle übersetzten WGL Befehle enthält.
|-
|[http://developer.3dlabs.com/documents/wglmanpage_index.htm 3dLabs]
|{{Englisch}}
|Sammlung einiger WGL Befehlsspezifikationen.
|-
|}

=== GLUT ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://freeglut.sourceforge.net/docs/api.php The freeglut Projekt]
|{{Englisch}}
|Englischsprachige Dokumentation zum OpenGL Utility Toolkit kurz GLUT.
|-
|}

=== SDL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:SDL|DGL Wiki - Kategorie SDL]]
|{{Deutsch}}
|Übersicht aller auf die SDL bezogenen Artikel hier im Wiki. Darunter befinden sich eine Vielzahl von Übersetzungen der SDL Befehlspezifikationen. Diese können auch in der [[SDL-Funktionsübersicht]] gefunden werden.
|-
|[http://www.libsdl.org/cgi/docwiki.cgi/SDL_20API libsdl.org]
|{{Englisch}}
|Das Dokumentationswiki von libSDL.org enthält die komplette Dokumenation zur SDL in englischer Sprache.
|-
|-
|[http://www.fp.sdl.de.vu/ fp.sdl.de.vu]
|{{Englisch}}
| Eine Webseite die speziell Informationen über die Programmierung von SDL unter Freepascal zur Verfügung stellt.
|-
|}

== FAQs ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[FAQ| DGL Wiki - FAQ]]
|{{Deutsch}}
|Ein FAQ (Frequently Asked Questions = Häufig gestellte Fragen) zu DelphiGL.com und dem DGL Wiki.
|-
|[http://www.3dsource.de/faq/index.htm 3dsource.de]
|{{Deutsch}}
|Ein FAQ zu Fragen rund um OpenGL.
|-
|}

== Effekte und Techniken mit OpenGL ==

===Glow===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamasutra.com/view/feature/2107/realtime_glow.php Gamasutra]
|{{Englisch}}
|Beschreibt, wie man mit Hilfe von Shader(hier DirectX Shader) den Gloweffekt in Realtime umsetzt. Dabei wird erst die Technik dahinter erklährt, und dann wie man sie Schritt für Schritt umsetzt.
|-
|[http://collective.valve-erc.com/index.php?go=tron1 valve-erc.com]
|{{Englisch}}
|Schritt für Schritt Anleitung, wie man mit Hilfe von Cg in OpenGL den Glow Effekt realisieren kann
|-
|}

===HDR===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamedev.net/columns/hardcore/hdrrendering/ gamedev.net]
|{{Englisch}}
|Hier wird sehr kurz eingeleitet, was HDR Rendering überhaupt ist, dann wird der Aufbau des *.hdr Formats erläutert, und dann geht es schon von 0 auf 100 zum Programmieren. Erklährungen gibt es kaum, dafür werden fertige Shader(für DirectX) geboten.
|-
|[http://www.gamedev.net/reference/articles/article2208.asp gamedev.net]
|{{Englisch}}
|Beschreibt auch nur etwas kurz das HDR Verfahren, jedoch mit mehr mathematischen Hintergrund in Sachen Tonemapping. Beispielcode für Tonemapping in C++ liegt bei.
|-
|}

===BSP Bäume===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.3dtechdev.com/tutorials/leafbsp/3dbsptrees.html 3dtechdev.com]
|{{Englisch}}
|Das beste Dokument überhaupt, für allem die selber BSP Bäume compilieren möchte. Ist belegt mit sehr viel Grafik. Erst beginnt er das Prinzip allgemein zum umschreiben, dann wird alles genau erläutert, und mit verständlichen Pseudocode untermalt.
|-
|[http://www.3dtechdev.com/tutorials/illegalgeometry/illegalgeometrytut.html 3dtechdev.com]
|{{Englisch}}
|Nicht ganz so gut geworden, wie sein erstes Tutorial, aber erklährt auch sehr gut, wie man illegale Geometrie aufspürt und beseitigt. Wieder mit Grafiken und Pseudocodes verständlich belegt. Hiermit kann man seinem Map-Compiler den letzten Schliff verleien.
|-
|[http://www.gamedev.net/reference/articles/article981.asp Gamedev]
|{{Englisch}}
|Von Michael Abrash, dürfte der ''Erfinder'' von Quake sein. Naja, meine Englischkenntnisse reichen hier nicht ganz aus, um den Text zu verstehen. Ist etwas umständlich geschrieben. Dafür mit Grafiken unterlegt.
|-
|[http://www.zfx-online.de/Tutorials.php?ID=11 Part 1 - Allgemein]
|{{Deutsch}}
|Einzigste deutsche Referenz zu BSP Bäumen, dafür Daumen hoch. Ist aber nicht das Wahre: schlechter C Code, und ich hatte auch nicht den Einduck, das er die Theorie zu diesem Thema bis in die Tiefe verstanden hat(oder er wollte es nicht zu akademisch Erklähren oO). Aber ein guter Einstieg in dieses Thema.
|-
|[http://www.zfx-online.de/Tutorials.php?ID=13 Part 2 - Kollision und PVS]
|{{Deutsch}}
|-
|[http://www.cs.uwec.edu/~stevende/cs455/programs/GameTutorials%20-%20Quake%203%20BSP%20Format.htm Quake3 *.bsp Format]
|{{Englisch}}
|Die beste Dokumentation für das BSP Format, die ich gefunden habe, besser als den Quake3 Sourcecode zu durchforsten. Leider etwas magere Eklährung zu wichtigen Themen wie Patches(Curved Surfaces). Ich pers. hatte jetzt 1 1/2 Wochen gebraucht, um das *.bsp Format vollständig zu verstehen. Ist aber anscheinend die beste Format Dokumentation im Netz.
|-
|[http://www.flipcode.com/articles/article_q2bsp.shtml Quake2 *.bsp Format]
|{{Englisch}}
|Kann auch nur soviel sagen, wie beim Link zuvor. Es fehlen hier auch zum Teil Informationen. Man muss halt viel ausprobieren, und sich den Quake 2 Source zu Herzen nehmen, damit man es versteht.
|-
|}

===Himmel & Wolken===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamedev.net/community/forums/topic.asp?topic_id=86024 Gamedev]
|{{Englisch}}
|Guter Thread mit vielen Anregungen und Links.
|-
|[http://www.gamedev.net/community/forums/topic.asp?topic_id=135654 Gamedev]
|{{Englisch}}
|Hier wird die Diskussion zum obigen Link weitergeführt.
|-
|[http://freespace.virgin.net/hugo.elias/models/m_clouds.htm Plasma]
|{{Englisch}}
|Eine nette Idee um Plasma in Echtzeit zu generieren, und zu verändern. Leider nichts zum Shading.
|-
|[http://nis-lab.is.s.u-tokyo.ac.jp/~nis/cdrom/sig00_cloud.pdf 3D Wolken]
|{{Englisch}}
|Paper über generieren und rendern von 3 dimensionalen Wolken inklusive Schatten und Lichtstrahlen. Ich hab nur den Lichtstahlen-Algorithmus ausprobiert. Saulangsam aber sehr einfach zu implementieren. Einen Blick ist es auf jeden Fall wert.
|-
|[http://www.geocities.com/ngdash/whitepapers/skydomecolor.html Skydome]
|{{Englisch}}
|Wenn man mal schnell gute Farben für seinen Skydome braucht...
|}

===Terrain===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.flipcode.com/articles/article_geomipmaps.shtml FlipCode]
|{{Englisch}}
|Artikel zu Geomipmaping. Zummindest hab ich es hier zum ersten mal gesehen. Und es funzt ganz gut.
|-
|[http://www.vterrain.org Virtual Terrain Project]
|{{Englisch}}
|Eine Seite mit Links und Artikeln zu allem, was etwas mit Terrainrendering zu tun hat.
|-
|}

===Sonstiges===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[Materialsammlung]]
|{{Deutsch}}
|Sammlung von gängigen Parametern für [[glMaterial]] hier im Wiki.
|-
|[http://freespace.virgin.net/hugo.elias/radiosity/radiosity.htm Radiosity]
|{{Englisch}}
|Erklährt sehr schön die Funktionsweise von Radiosity, liefert Beispielcodes und ist recht gut illustriert.
|-
|[http://legion.gibbering.net/projectx/paper/shadow%20mapping/ Shadowmapping]
|{{Englisch}}
|Beschreibt das Trapezoidal Shadow Mapping - Verfahren für gerichte Lichter.
|-
|[http://www.flipcode.com/articles/article_generatingnames.shtml Namensgenerator]
|{{Englisch}}
|Per Zufallsgenrator Namen erzeugen, und nie wieder kreativ werden müssen.
|-
|[http://www.paulsprojects.net/tutorials/simplebump/simplebump.html Bumpmapping]
|{{Englisch}}
|Bumpmapping auf Lowend-Grakas. Damals war Bumpmapping noch was ganz tolles...
|-
|[http://www.paulsprojects.net/opengl/dpreflect/dpreflect.html Dot Product Reflect]
|{{Englisch}}
|zwar nur ne Demo, aber wenn man schon immer mal mit EMBM das Wasser aus Morrowind nachproggen wollte...
|-
|}

== Beispiele/Demos mit Quelltext ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.delphigl.de DelphiGL.de]
|{{Deutsch}}
| Hier finden sich besonders eindrucksvolle Newton Physik Demos. Meißtens sogar mit Quelltext.
|-
|[http://www.shadow3d.de.vu/ Shadow 3D]
|{{Deutsch}}
| Hier finden sich zwei Demos wie man Quake 3 Modelle lädt und eine glSlang Demo
|-
|[[Shadersammlung]] im DGL Wiki
|{{Deutsch}}
| Hier findet man freie Shadersourcen.
|-
|[http://www.humus.name Humus]
|{{Englisch}}
| Diverse eindrucksvolle Demos zu verschiedenen Techniken, häufig mit Quelltext in C (teilweise OpenGL / DirectX)
|}

== weitere Links ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www-user.tu-chemnitz.de/~pester/Lehre/CompGeo.pdf CompGeo.pdf]
|{{Deutsch}}
| Script "Einführung in die Computergeometrie" von Dr. Pester (TU-Chemnitz). Ideales Nachschlagewerk für die Mathematik die einem bei der Grafikprogrammierung so begegnet.
|-
|[http://www.robsite.de/ robsite.de]
|{{Deutsch}}
| Auf dieser riesigen Seite finden sich auch viele weitere Links über verschiedene Themen der 3D Programmierung.
|-
|[http://www.3dlinks.com/links.cfm?categoryid=3&subcategoryid=21 3dlinks.com]
|{{Englisch}}
| Diese Seite hat es sich zur Hauptaufgabe gemacht Links auf Seiten mit dem Thema 3D zu sammeln.
|-
|[http://www.two-kings.de/links.html two-kings.de]
|{{Englisch}}
| Sammlung diverser interessanter Links, vorallem auf Themen im gamedev-Forum verweisend.
|-
|[http://www.delgine.com Delgine.com]
|{{Englisch}}
| Heimat des freien 3D Modellers "DeleD", welcher in Delphi programmiert ist. Ihr findet dort auch Modellpackete, Texturpackete, Plugins und Hilfe bei der Programmierung von Delphi und OpenGL.
|}

= Spieleentwicklung =

==Allgemein==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.spieleprogrammierung.net/ Spieleprogrammierung - OpenGL - GLSL - OpenAL - KI - Animation - Spielephysik]
|{{Deutsch}}
|Auf dieser Seite findet Ihr Artikel, Tutorials und Programmbeispiele rund um das Thema Spieleprogrammierung. Programmiersprache ist hier C/C++.
|-
|[http://graphics-and-physics-framework.spieleprogrammierung.net/ OpenGL Graphics And Physics Framework]
|{{Deutsch}}
|Auf dieser Seite findet Ihr ein frei verfügbares OpenGL basiertes Grafik und Physik Framework (LGPL-Lizenz) samt zugehöriger Probammbeispiele. Programmiersprache ist hier C/C++.
|-
|[http://audio-framework.spieleprogrammierung.net/ OpenAL Audio Framework]
|{{Deutsch}}
|Auf dieser Seite findet Ihr ein frei verfügbares OpenAL Audio Framework (LGPL-Lizenz) samt zugehöriger Probammbeispiele. Unterstützt werden 3D Sounds, EFX (EAX Alternative) Reverb Effekte sowie Audio Streaming (Music and Voices). Programmiersprache ist hier C/C++.
|-
|[http://spieleentwicklung-im-web.spieleprogrammierung.net/ Spieleentwicklung im Web]
|{{Deutsch}}
|Auf dieser Seite findet Ihr Links (E-Books, Präsentationen, wissenschaftliche Arbeiten und Tutorials) zu verschiedenen Themengebieten der Spieleentwicklung.
|-
|}

==Kopierschutz==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://inner-smile.com/nocrack.phtml Inner-Smile.com]
|{{Englisch}}
| Seite mit Gedanken zum Thema "Wie schütze ich meine Programme vor Crackern". Falls die Seite nicht erreichbar ist hat Google noch ne [http://www.google.com/search?q=cache:hpqPT5G4WB0J:www.inner-smile.com/nocrack.phtml+http://inner-smile.com/nocrack.phtml&hl=de&gl=de&ct=clnk&cd=1 Version im Archiv].
|-
|}

== Künstliche Intelligenz ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.kbs.uni-hannover.de/Lehre/KI2/Presentationen/presentation9798/esprit/spieltheorie/spieltheorie.html Uni-Hannover - Spieltheorie]
|{{Deutsch}}
|Artikel über die Grundlagen von KI in Spielen.
|-
|[http://www.robsite.de/tutorials.php?tut=ki Robsite KI-Tutorials]
|{{Deutsch}}
| Sammlung von Texten zum Thema KI in Spielen. Beispiele sind meist in C++.
|-
|[http://ai-depot.com/ AI-Depot.com]
|{{Englisch}}
| Seite die sich ausschließlich mit KI in Spielen beschäftigt.
|-
|[http://www.ai-junkie.com/links.html AI-Junkie.com]
|{{Englisch}}
|Linkseite mit vielen KI relevanten Links. Die Seite AI-Junie selbst behandelt auch viele Themen rund um KI.
|-
|[http://www.aiwisdom.com/ AIWisdom.com]
|{{Englisch}}
|Seite die sich mit KIs in Spielen beschäftigt und sich zum Ziel gesetzt hat, alle Artikel zum Thema zu finden und zu Katalogisieren. Es gibt hier auch Artikel über die KIs bestehender Spiele.
|-
|[http://www.aiguru.com/ AIGuru.com]
|{{Englisch}}
|Newsseite zum Thema KI, Künstliches Leben, Hiernforschung, Robotik, Nanotechnologie - Halt alles was Spass macht.
|-
|[http://www.generation5.org/ Generation5.org]
|{{Englisch}}
|Seite über KI, Robotik, etc. . Leider scheint die Seite Probleme zu haben regelmäßig aktualisiert zu werden. Aber zumindest sollte man einige Artikel finden. Die werden ja nicht schlecht.
|-
|www.gameai.com
|{{Englisch}}
|''Wurde Januar 2010 als down gemeldet. Weiss irgendwer etwas genaueres?'' Seite zum Thema KI in Spielen. Soll wohl einen gewissen Stellenwert in der AI-Szene haben.
|-
|[http://www-i1.informatik.rwth-aachen.de/~algorithmus/algo19.php Algorithmus der Woche - Informatikjahr 2006]
|{{Deutsch}}
|Vielleicht schon etwas älter aber doch eine gute Anleitung um eine einfache Schach-KI zu erstellen.
|}

= Ressourcen =
In dieser Gruppe finden sich Links um die Ressourcen für Eure Projekte zu erstellen.

== Texturen / 2D-Grafiken ==

=== Texturen ===
{| width = "100%" {{Prettytable_B1}}
!width="20%"|Link
!width="10%"|Genre
!width="10%"|Lizenz
!width="5%"|GPL
!width="5%"|MPL
!width="5%"|OSS
!width="5%"|CSS
!width="5%"|Komm.
!width="35%"|Bemerkungen
|-
|[http://www.davegh.com/vg/home.htm]
|Fantasy
|[http://www.davegh.com/vg/termsandconditions.htm Eigene]
|?
|?
|✔
|✔
|✘
|Die Lizenz vererbt sich in die Projekte hinein.
|-
|url
|Futuristisch, Mittelalter, etc.
|CC-BY-SA, etc., gerne auch mit Direktlink auf die Lizenzseite, so vorhanden.
|✔/✘/?
|✔/✘/?
|✔/✘/?
|✔/✘/?
|✔/✘/?
|Alle Bilder sind von Käse
|}
'''Legende:'''
:'''Kostenpflichtige Seiten''' sind mit einem * zu '''kennzeichnen'''
:GPL: Kompatibel mit der GPL
:MPL: Kompatibel mit der MPL
:OSS: Verwendung in OpenSource Software nicht verboten
:CSS: Verwendung in ClosedSource Software nicht verboten
:Komm: Verwendung in kommerzieller Software nicht verboten

=== Texturerstellung ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://3d.diehlsworld.de/textures/index.htm 3d.diehlsworld.de]
|{{Deutsch}}
|Auf dieser Seite findet ihr kurze aber inhaltlich reiche Tutorials zu der Frage "Wie erstelle ich XXXXX-Texturen". Dabei reicht die Palette von Untergrundtexturen wie Gras, Sand , Fels und Wasser (und Kombinationen dieser) bis hin zu Blitzen und Partikeln. Als Programm wird hier Photoshop verwendet.
|-
|[http://www.gimps.de/gimp/textur-muster/ gimps.de]
|{{Deutsch}}
|Schritt für Schritt Anleitungen wie man mit Gimp verschiedene Texturen erstellt.
|-
|[http://cbt.k090999.de/gimp.php#texturen k090999.de]
|{{Deutsch}}
|Gimptutorials zum Erstellen verschiedene Texturen.
|}

== Modelle / 3D-Grafiken ==

=== Blender ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://blendpolis.de/f/viewtopic.php?t=5786 Blendpolis]
|{{Deutsch}}
| Ein Thread im Forum von [http://blendpolis.de Blendpolis] in dem '''sehr''' viele Tutorials aufgelistet sind
|-
|[http://blendpolis.de/f/article_cat.php?fldAuto=7 Blendpolis]
|{{Deutsch}}
| Eigentliche Tutorial Seite von [http://blendpolis.de Blendpolis] die Auswahl ist hier aber nicht so groß
|-
|[http://wikivid.com/index.php/Blender Blender at wikivid.com]
|{{Englisch}}
| Linksammlung von Blender Video Tutorials
|-
|[http://www.blender.org/education-help/tutorials/getting-started/ blender3d.org]
|{{Englisch}}
| Auch die Heimatseite von Blender bietet viele Tutorials unter anderm auch Video Tuorials
|-
|[http://www.Blenderunderground.com Blenderunderground]
|{{Englisch}}
| '''sehr gute''' Video-Tutorials
|}

== Sounds ==

===Musik===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.jamendo.com/ Jamendo.com]
|{{Englisch}}
|Viele Künstler stellen hier ihre Alben unter einer Creative Commons Lizenz online. Man kann dort die Künstler auch kontaktieren und fragen ob man ihre Musik nutzen kann. Taugt außerdem als Radio! ;)
|-
|[http://incompetech.com/m/c/royalty-free/ Incompetech.com]
|{{Englisch}}
|Viele sehr schön gemacht instrumentale Musik aus allen möglichen Genres. Sie ist frei verwenderbar, wenn man den Macher der Musik (Kevin MacLeod) in seinem Programm erwähnt. Aber das hat er auch verdient. Folgende Programme nutzen beispielsweise (auch) Musik von incompetech.com:
* OpenParty
|-
|}

===Soundeffekte===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.freesound.org/ freesound.org]
|{{Englisch}}
|Diverse Sounds unter [http://www.creativecommons.org/ CreativeCommons] Lizenzen.
|}

===Soundprogramme===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://audacity.sourceforge.net/?lang=de Sourceforgeseite von Audacity]
|{{Deutsch}}
|Ein einfaches, freies Programm um Sounddateien zu bearbeiten. Man kann es auch nutzen um Soundeffekte neu zu erstellen, indem man z.B. ein Geräusch mit dem Mikrofon aufnimmt und einige Effekt anwendet, um es passender und nicht mehr aufgenommen klingen zu lassen.
|-
|[http://lmms.sourceforge.net/ LMMS]
|{{Englisch}}
|LMMS (Linux MultiMedia Studio) ist ein OpenSource+Freeware Composer-Programm ähnlich zum bekannteren aber auch teuren CuBase(r). Trotz des Namens auch für Windows erhältlich.
|}

Link

2011-08-13T17:57:25Z

Lord horazont: /* Texturen */ davegh hinzugefügt.

Diese Linksammlung soll allgemeine Links zu unterschiedlichen Themen bieten, die mit der Multimediaentwicklung zu tun haben.
{{Hinweis|Vielleicht ist eine Zusammenführung mit [[Tool]] sinnvoll!}}
{{Hinweis|Vielleicht ist eine Aufteilung in Unterseiten sinnvoll (möglicherweise mit Kategorien)}}

= Entwicklung mit OpenGL =

== Hardwareinfos ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://delphi3d.net/hardware/listreports.php OpenGL Hardware Registry - Hardwareübersicht]
|{{Englisch}}
|Eine Datenbank aller Grafikkarten die in der Harware Registry vorhanden sind. Die einzelnen Artikel enthalten Infos darüber, welche Extensions von der Grafikkarte unterstützt werden.
|-
|[http://delphi3d.net/hardware/allexts.php OpenGL Hardware Registry - Extensionübersicht]
|{{Englisch}}
|Eine Datenbank aller Extensions die in der Harware Registry vorhanden sind. Die einzelnen Artikel enthalten Infos darüber, welche Grafikkarten die entsprechende Extension unterstützen.
|-
|}

== Tutorials ==

{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
||[[Tutorial|DGL Wiki - Tutorial]]
|{{Deutsch}}
|DelphiGL.com ist Betreiber dieses Wikis und stellt eine Vielzahl Tutorials mit Schwehrpunkt OpenGL zur Verfügung.
Neben Tutorials für Einsteiger und OpenGL Anfänger gibt es auch fortgeschrittene Themen wie Shader oder Partikelsysteme.Sprache der Wahl ist hier Delphi.
|-
|[http://www.joachimrohde.com/cms/xoops/modules/articles/index.php?cat_id=1 joachimrohde.com]
|{{Deutsch}}
|Auf dieser Seite findet ihr deutsche Übersetzungen der bekannten NeHe Tutorials. Sprache der Wahl ist hier C++.
|-
|[http://www.cg.tuwien.ac.at/studentwork/VRSem96/OpenGL/ Technische Universität Wien]
|{{Deutsch}}
|
|-
|[http://nehe.gamedev.net/ Nehe]
|{{Englisch}}
|Die berühmt berüchtigten NeHe Tutorials sind eine umfangreiche Sammlung an Tutorials zum Thema OpenGL. Von Anfängertutorials bis hin zu komplexen Effekten wird alles behandelt. Sprache der Wahl ist hier C++. (Eine Übersetzung der NeHe Tutorials findet ihr bei Joachim Rhode (siehe oben). )
|-
|[http://www.sulaco.co.za/tut.htm sulaco.co.za]
|{{Englisch}}
| OpenGL Beispiele in Delphi
|}

== OpenGL Funktionen ==

=== GL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GL|DGL Wiki - Kategorie GL]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten OpenGL Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL.tar.gz OpenGL.org - Orginal Spezifkationen]
|{{Englisch}}
|Die Orginalspezifikationen der OpenGL 1.0 und OpenGL 1.1 Befehle. (Diese HTML-Dokumente sind nicht Copy&Paste freundlich, da sie vermutlich automatisch aus vorhandenen Dateien (Postscript) erzeugt wurden.)
|-
|[http://developer.3dlabs.com/documents/glmanpage_index.htm 3dLabs]
|{{Englisch}}
|Die Orginalspezifikationen der OpenGL 1.0 und OpenGL 1.1 Befehle.
|-
|[http://www.mevis.de/~uwe/opengl/opengl.html mevis.de]
|{{Englisch}}
|Sammlung von Englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|[http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/glfunc01_4f03.asp MSDN von Microsoft]
|{{Englisch}}
|OpenGL Dokumentation in der MSDN. Die Erklärung der MSDN sind meist keine reinen Kopien der Orginalspezifikationen, sondern enthalten hin und wieder auch zusätzliche Informationen, oder formulieren Texte auf verständlichere Art und Weise.
|-
|}

=== GLU ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GLU|DGL Wiki - Kategorie GLU]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten GLU Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/glu/ OpenGL.org - Orginal Spezifkationen]
|{{Englisch}}
|Orginalspezifikationen für die GLU Befehle. (Diese HTML-Dokumente sind nicht Copy&Paste freundlich, da sie vermutlich automatisch aus vorhandenen Dateien (Postscript) erzeugt wurden.)
|-
|[http://www.mevis.de/~uwe/opengl/opengl.html mevis.de]
|{{Englisch}}
|Sammlung von englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|[http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/glufnc01_0e43.asp MSDN von Microsoft]
|{{Englisch}}
|GLU Dokumentation in der MSDN. Die Erklärung der MSDN sind meist keine reinen Kopien der Orginalspezifikationen, sondern enthalten hin und wieder auch zusätzliche Informationen, oder formulieren Texte auf verständlichere Art und Weise.
|-
|}

=== GLX ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GLX|DGL Wiki - Kategorie GLX]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten GLX Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/glx/ OpenGL.org - Orginal Spezifkationen]
|{{Englisch}}
|Orgninalspezifikationen der GLX Befehle bei OpenGL.org.
|-
|[http://www.mevis.de/~uwe/opengl/opengl.html mevis.de]
|{{Englisch}}
|Sammlung von Englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|}

=== WGL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:WGL|DGL Wiki - Kategorie WGL]]
|{{Deutsch}}
|Wiki-Kategorie die alle übersetzten WGL Befehle enthält.
|-
|[http://developer.3dlabs.com/documents/wglmanpage_index.htm 3dLabs]
|{{Englisch}}
|Sammlung einiger WGL Befehlsspezifikationen.
|-
|}

=== GLUT ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://freeglut.sourceforge.net/docs/api.php The freeglut Projekt]
|{{Englisch}}
|Englischsprachige Dokumentation zum OpenGL Utility Toolkit kurz GLUT.
|-
|}

=== SDL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:SDL|DGL Wiki - Kategorie SDL]]
|{{Deutsch}}
|Übersicht aller auf die SDL bezogenen Artikel hier im Wiki. Darunter befinden sich eine Vielzahl von Übersetzungen der SDL Befehlspezifikationen. Diese können auch in der [[SDL-Funktionsübersicht]] gefunden werden.
|-
|[http://www.libsdl.org/cgi/docwiki.cgi/SDL_20API libsdl.org]
|{{Englisch}}
|Das Dokumentationswiki von libSDL.org enthält die komplette Dokumenation zur SDL in englischer Sprache.
|-
|-
|[http://www.fp.sdl.de.vu/ fp.sdl.de.vu]
|{{Englisch}}
| Eine Webseite die speziell Informationen über die Programmierung von SDL unter Freepascal zur Verfügung stellt.
|-
|}

== FAQs ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[FAQ| DGL Wiki - FAQ]]
|{{Deutsch}}
|Ein FAQ (Frequently Asked Questions = Häufig gestellte Fragen) zu DelphiGL.com und dem DGL Wiki.
|-
|[http://www.3dsource.de/faq/index.htm 3dsource.de]
|{{Deutsch}}
|Ein FAQ zu Fragen rund um OpenGL.
|-
|}

== Effekte und Techniken mit OpenGL ==

===Glow===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamasutra.com/view/feature/2107/realtime_glow.php Gamasutra]
|{{Englisch}}
|Beschreibt, wie man mit Hilfe von Shader(hier DirectX Shader) den Gloweffekt in Realtime umsetzt. Dabei wird erst die Technik dahinter erklährt, und dann wie man sie Schritt für Schritt umsetzt.
|-
|[http://collective.valve-erc.com/index.php?go=tron1 valve-erc.com]
|{{Englisch}}
|Schritt für Schritt Anleitung, wie man mit Hilfe von Cg in OpenGL den Glow Effekt realisieren kann
|-
|}

===HDR===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamedev.net/columns/hardcore/hdrrendering/ gamedev.net]
|{{Englisch}}
|Hier wird sehr kurz eingeleitet, was HDR Rendering überhaupt ist, dann wird der Aufbau des *.hdr Formats erläutert, und dann geht es schon von 0 auf 100 zum Programmieren. Erklährungen gibt es kaum, dafür werden fertige Shader(für DirectX) geboten.
|-
|[http://www.gamedev.net/reference/articles/article2208.asp gamedev.net]
|{{Englisch}}
|Beschreibt auch nur etwas kurz das HDR Verfahren, jedoch mit mehr mathematischen Hintergrund in Sachen Tonemapping. Beispielcode für Tonemapping in C++ liegt bei.
|-
|}

===BSP Bäume===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.3dtechdev.com/tutorials/leafbsp/3dbsptrees.html 3dtechdev.com]
|{{Englisch}}
|Das beste Dokument überhaupt, für allem die selber BSP Bäume compilieren möchte. Ist belegt mit sehr viel Grafik. Erst beginnt er das Prinzip allgemein zum umschreiben, dann wird alles genau erläutert, und mit verständlichen Pseudocode untermalt.
|-
|[http://www.3dtechdev.com/tutorials/illegalgeometry/illegalgeometrytut.html 3dtechdev.com]
|{{Englisch}}
|Nicht ganz so gut geworden, wie sein erstes Tutorial, aber erklährt auch sehr gut, wie man illegale Geometrie aufspürt und beseitigt. Wieder mit Grafiken und Pseudocodes verständlich belegt. Hiermit kann man seinem Map-Compiler den letzten Schliff verleien.
|-
|[http://www.gamedev.net/reference/articles/article981.asp Gamedev]
|{{Englisch}}
|Von Michael Abrash, dürfte der ''Erfinder'' von Quake sein. Naja, meine Englischkenntnisse reichen hier nicht ganz aus, um den Text zu verstehen. Ist etwas umständlich geschrieben. Dafür mit Grafiken unterlegt.
|-
|[http://www.zfx-online.de/Tutorials.php?ID=11 Part 1 - Allgemein]
|{{Deutsch}}
|Einzigste deutsche Referenz zu BSP Bäumen, dafür Daumen hoch. Ist aber nicht das Wahre: schlechter C Code, und ich hatte auch nicht den Einduck, das er die Theorie zu diesem Thema bis in die Tiefe verstanden hat(oder er wollte es nicht zu akademisch Erklähren oO). Aber ein guter Einstieg in dieses Thema.
|-
|[http://www.zfx-online.de/Tutorials.php?ID=13 Part 2 - Kollision und PVS]
|{{Deutsch}}
|-
|[http://www.cs.uwec.edu/~stevende/cs455/programs/GameTutorials%20-%20Quake%203%20BSP%20Format.htm Quake3 *.bsp Format]
|{{Englisch}}
|Die beste Dokumentation für das BSP Format, die ich gefunden habe, besser als den Quake3 Sourcecode zu durchforsten. Leider etwas magere Eklährung zu wichtigen Themen wie Patches(Curved Surfaces). Ich pers. hatte jetzt 1 1/2 Wochen gebraucht, um das *.bsp Format vollständig zu verstehen. Ist aber anscheinend die beste Format Dokumentation im Netz.
|-
|[http://www.flipcode.com/articles/article_q2bsp.shtml Quake2 *.bsp Format]
|{{Englisch}}
|Kann auch nur soviel sagen, wie beim Link zuvor. Es fehlen hier auch zum Teil Informationen. Man muss halt viel ausprobieren, und sich den Quake 2 Source zu Herzen nehmen, damit man es versteht.
|-
|}

===Himmel & Wolken===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamedev.net/community/forums/topic.asp?topic_id=86024 Gamedev]
|{{Englisch}}
|Guter Thread mit vielen Anregungen und Links.
|-
|[http://www.gamedev.net/community/forums/topic.asp?topic_id=135654 Gamedev]
|{{Englisch}}
|Hier wird die Diskussion zum obigen Link weitergeführt.
|-
|[http://freespace.virgin.net/hugo.elias/models/m_clouds.htm Plasma]
|{{Englisch}}
|Eine nette Idee um Plasma in Echtzeit zu generieren, und zu verändern. Leider nichts zum Shading.
|-
|[http://nis-lab.is.s.u-tokyo.ac.jp/~nis/cdrom/sig00_cloud.pdf 3D Wolken]
|{{Englisch}}
|Paper über generieren und rendern von 3 dimensionalen Wolken inklusive Schatten und Lichtstrahlen. Ich hab nur den Lichtstahlen-Algorithmus ausprobiert. Saulangsam aber sehr einfach zu implementieren. Einen Blick ist es auf jeden Fall wert.
|-
|[http://www.geocities.com/ngdash/whitepapers/skydomecolor.html Skydome]
|{{Englisch}}
|Wenn man mal schnell gute Farben für seinen Skydome braucht...
|}

===Terrain===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.flipcode.com/articles/article_geomipmaps.shtml FlipCode]
|{{Englisch}}
|Artikel zu Geomipmaping. Zummindest hab ich es hier zum ersten mal gesehen. Und es funzt ganz gut.
|-
|[http://www.vterrain.org Virtual Terrain Project]
|{{Englisch}}
|Eine Seite mit Links und Artikeln zu allem, was etwas mit Terrainrendering zu tun hat.
|-
|}

===Sonstiges===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[Materialsammlung]]
|{{Deutsch}}
|Sammlung von gängigen Parametern für [[glMaterial]] hier im Wiki.
|-
|[http://freespace.virgin.net/hugo.elias/radiosity/radiosity.htm Radiosity]
|{{Englisch}}
|Erklährt sehr schön die Funktionsweise von Radiosity, liefert Beispielcodes und ist recht gut illustriert.
|-
|[http://legion.gibbering.net/projectx/paper/shadow%20mapping/ Shadowmapping]
|{{Englisch}}
|Beschreibt das Trapezoidal Shadow Mapping - Verfahren für gerichte Lichter.
|-
|[http://www.flipcode.com/articles/article_generatingnames.shtml Namensgenerator]
|{{Englisch}}
|Per Zufallsgenrator Namen erzeugen, und nie wieder kreativ werden müssen.
|-
|[http://www.paulsprojects.net/tutorials/simplebump/simplebump.html Bumpmapping]
|{{Englisch}}
|Bumpmapping auf Lowend-Grakas. Damals war Bumpmapping noch was ganz tolles...
|-
|[http://www.paulsprojects.net/opengl/dpreflect/dpreflect.html Dot Product Reflect]
|{{Englisch}}
|zwar nur ne Demo, aber wenn man schon immer mal mit EMBM das Wasser aus Morrowind nachproggen wollte...
|-
|}

== Beispiele/Demos mit Quelltext ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.delphigl.de DelphiGL.de]
|{{Deutsch}}
| Hier finden sich besonders eindrucksvolle Newton Physik Demos. Meißtens sogar mit Quelltext.
|-
|[http://www.shadow3d.de.vu/ Shadow 3D]
|{{Deutsch}}
| Hier finden sich zwei Demos wie man Quake 3 Modelle lädt und eine glSlang Demo
|-
|[[Shadersammlung]] im DGL Wiki
|{{Deutsch}}
| Hier findet man freie Shadersourcen.
|-
|[http://www.humus.name Humus]
|{{Englisch}}
| Diverse eindrucksvolle Demos zu verschiedenen Techniken, häufig mit Quelltext in C (teilweise OpenGL / DirectX)
|}

== weitere Links ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www-user.tu-chemnitz.de/~pester/Lehre/CompGeo.pdf CompGeo.pdf]
|{{Deutsch}}
| Script "Einführung in die Computergeometrie" von Dr. Pester (TU-Chemnitz). Ideales Nachschlagewerk für die Mathematik die einem bei der Grafikprogrammierung so begegnet.
|-
|[http://www.robsite.de/ robsite.de]
|{{Deutsch}}
| Auf dieser riesigen Seite finden sich auch viele weitere Links über verschiedene Themen der 3D Programmierung.
|-
|[http://www.3dlinks.com/links.cfm?categoryid=3&subcategoryid=21 3dlinks.com]
|{{Englisch}}
| Diese Seite hat es sich zur Hauptaufgabe gemacht Links auf Seiten mit dem Thema 3D zu sammeln.
|-
|[http://www.two-kings.de/links.html two-kings.de]
|{{Englisch}}
| Sammlung diverser interessanter Links, vorallem auf Themen im gamedev-Forum verweisend.
|-
|[http://www.delgine.com Delgine.com]
|{{Englisch}}
| Heimat des freien 3D Modellers "DeleD", welcher in Delphi programmiert ist. Ihr findet dort auch Modellpackete, Texturpackete, Plugins und Hilfe bei der Programmierung von Delphi und OpenGL.
|}

= Spieleentwicklung =

==Allgemein==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.spieleprogrammierung.net/ Spieleprogrammierung - OpenGL - GLSL - OpenAL - KI - Animation - Spielephysik]
|{{Deutsch}}
|Auf dieser Seite findet Ihr Artikel, Tutorials und Programmbeispiele rund um das Thema Spieleprogrammierung. Programmiersprache ist hier C/C++.
|-
|[http://graphics-and-physics-framework.spieleprogrammierung.net/ OpenGL Graphics And Physics Framework]
|{{Deutsch}}
|Auf dieser Seite findet Ihr ein frei verfügbares OpenGL basiertes Grafik und Physik Framework (LGPL-Lizenz) samt zugehöriger Probammbeispiele. Programmiersprache ist hier C/C++.
|-
|[http://audio-framework.spieleprogrammierung.net/ OpenAL Audio Framework]
|{{Deutsch}}
|Auf dieser Seite findet Ihr ein frei verfügbares OpenAL Audio Framework (LGPL-Lizenz) samt zugehöriger Probammbeispiele. Unterstützt werden 3D Sounds, EFX (EAX Alternative) Reverb Effekte sowie Audio Streaming (Music and Voices). Programmiersprache ist hier C/C++.
|-
|[http://spieleentwicklung-im-web.spieleprogrammierung.net/ Spieleentwicklung im Web]
|{{Deutsch}}
|Auf dieser Seite findet Ihr Links (E-Books, Präsentationen, wissenschaftliche Arbeiten und Tutorials) zu verschiedenen Themengebieten der Spieleentwicklung.
|-
|}

==Kopierschutz==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://inner-smile.com/nocrack.phtml Inner-Smile.com]
|{{Englisch}}
| Seite mit Gedanken zum Thema "Wie schütze ich meine Programme vor Crackern". Falls die Seite nicht erreichbar ist hat Google noch ne [http://www.google.com/search?q=cache:hpqPT5G4WB0J:www.inner-smile.com/nocrack.phtml+http://inner-smile.com/nocrack.phtml&hl=de&gl=de&ct=clnk&cd=1 Version im Archiv].
|-
|}

== Künstliche Intelligenz ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.kbs.uni-hannover.de/Lehre/KI2/Presentationen/presentation9798/esprit/spieltheorie/spieltheorie.html Uni-Hannover - Spieltheorie]
|{{Deutsch}}
|Artikel über die Grundlagen von KI in Spielen.
|-
|[http://www.robsite.de/tutorials.php?tut=ki Robsite KI-Tutorials]
|{{Deutsch}}
| Sammlung von Texten zum Thema KI in Spielen. Beispiele sind meist in C++.
|-
|[http://ai-depot.com/ AI-Depot.com]
|{{Englisch}}
| Seite die sich ausschließlich mit KI in Spielen beschäftigt.
|-
|[http://www.ai-junkie.com/links.html AI-Junkie.com]
|{{Englisch}}
|Linkseite mit vielen KI relevanten Links. Die Seite AI-Junie selbst behandelt auch viele Themen rund um KI.
|-
|[http://www.aiwisdom.com/ AIWisdom.com]
|{{Englisch}}
|Seite die sich mit KIs in Spielen beschäftigt und sich zum Ziel gesetzt hat, alle Artikel zum Thema zu finden und zu Katalogisieren. Es gibt hier auch Artikel über die KIs bestehender Spiele.
|-
|[http://www.aiguru.com/ AIGuru.com]
|{{Englisch}}
|Newsseite zum Thema KI, Künstliches Leben, Hiernforschung, Robotik, Nanotechnologie - Halt alles was Spass macht.
|-
|[http://www.generation5.org/ Generation5.org]
|{{Englisch}}
|Seite über KI, Robotik, etc. . Leider scheint die Seite Probleme zu haben regelmäßig aktualisiert zu werden. Aber zumindest sollte man einige Artikel finden. Die werden ja nicht schlecht.
|-
|www.gameai.com
|{{Englisch}}
|''Wurde Januar 2010 als down gemeldet. Weiss irgendwer etwas genaueres?'' Seite zum Thema KI in Spielen. Soll wohl einen gewissen Stellenwert in der AI-Szene haben.
|-
|[http://www-i1.informatik.rwth-aachen.de/~algorithmus/algo19.php Algorithmus der Woche - Informatikjahr 2006]
|{{Deutsch}}
|Vielleicht schon etwas älter aber doch eine gute Anleitung um eine einfache Schach-KI zu erstellen.
|}

= Ressourcen =
In dieser Gruppe finden sich Links um die Ressourcen für Eure Projekte zu erstellen.

== Texturen / 2D-Grafiken ==

=== Texturen ===
{| width = "100%" {{Prettytable_B1}}
!width="20%"|Link
!width="10%"|Genre
!width="10%"|Lizenz
!width="5%"|GPL
!width="5%"|MPL
!width="5%"|OSS
!width="5%"|CSS
!width="5%"|Komm.
!width="35%"|Bemerkungen
|-
|[http://www.davegh.com/vg/home.htm]
|Fantasy
|[http://www.davegh.com/vg/termsandconditions.htm Eigene]
|?
|?
|ja
|ja
|nein
|Die Lizenz vererbt sich in die Projekte hinein.
|-
|url
|Futuristisch, Mittelalter, etc.
|CC-BY-SA, etc., gerne auch mit Direktlink auf die Lizenzseite, so vorhanden.
|ja/nein/?
|ja/nein/?
|ja/nein/?
|ja/nein/?
|ja/nein/?
|Alle Bilder sind von Käse
|}
'''Legende:'''
:'''Kostenpflichtige Seiten''' sind mit einem * zu '''kennzeichnen'''
:GPL: Kompatibel mit der GPL
:MPL: Kompatibel mit der MPL
:OSS: Verwendung in OpenSource Software nicht verboten
:CSS: Verwendung in ClosedSource Software nicht verboten
:Komm: Verwendung in kommerzieller Software nicht verboten

=== Texturerstellung ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://3d.diehlsworld.de/textures/index.htm 3d.diehlsworld.de]
|{{Deutsch}}
|Auf dieser Seite findet ihr kurze aber inhaltlich reiche Tutorials zu der Frage "Wie erstelle ich XXXXX-Texturen". Dabei reicht die Palette von Untergrundtexturen wie Gras, Sand , Fels und Wasser (und Kombinationen dieser) bis hin zu Blitzen und Partikeln. Als Programm wird hier Photoshop verwendet.
|-
|[http://www.gimps.de/gimp/textur-muster/ gimps.de]
|{{Deutsch}}
|Schritt für Schritt Anleitungen wie man mit Gimp verschiedene Texturen erstellt.
|-
|[http://cbt.k090999.de/gimp.php#texturen k090999.de]
|{{Deutsch}}
|Gimptutorials zum Erstellen verschiedene Texturen.
|}

== Modelle / 3D-Grafiken ==

=== Blender ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://blendpolis.de/f/viewtopic.php?t=5786 Blendpolis]
|{{Deutsch}}
| Ein Thread im Forum von [http://blendpolis.de Blendpolis] in dem '''sehr''' viele Tutorials aufgelistet sind
|-
|[http://blendpolis.de/f/article_cat.php?fldAuto=7 Blendpolis]
|{{Deutsch}}
| Eigentliche Tutorial Seite von [http://blendpolis.de Blendpolis] die Auswahl ist hier aber nicht so groß
|-
|[http://wikivid.com/index.php/Blender Blender at wikivid.com]
|{{Englisch}}
| Linksammlung von Blender Video Tutorials
|-
|[http://www.blender.org/education-help/tutorials/getting-started/ blender3d.org]
|{{Englisch}}
| Auch die Heimatseite von Blender bietet viele Tutorials unter anderm auch Video Tuorials
|-
|[http://www.Blenderunderground.com Blenderunderground]
|{{Englisch}}
| '''sehr gute''' Video-Tutorials
|}

== Sounds ==

===Musik===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.jamendo.com/ Jamendo.com]
|{{Englisch}}
|Viele Künstler stellen hier ihre Alben unter einer Creative Commons Lizenz online. Man kann dort die Künstler auch kontaktieren und fragen ob man ihre Musik nutzen kann. Taugt außerdem als Radio! ;)
|-
|[http://incompetech.com/m/c/royalty-free/ Incompetech.com]
|{{Englisch}}
|Viele sehr schön gemacht instrumentale Musik aus allen möglichen Genres. Sie ist frei verwenderbar, wenn man den Macher der Musik (Kevin MacLeod) in seinem Programm erwähnt. Aber das hat er auch verdient. Folgende Programme nutzen beispielsweise (auch) Musik von incompetech.com:
* OpenParty
|-
|}

===Soundeffekte===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.freesound.org/ freesound.org]
|{{Englisch}}
|Diverse Sounds unter [http://www.creativecommons.org/ CreativeCommons] Lizenzen.
|}

===Soundprogramme===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://audacity.sourceforge.net/?lang=de Sourceforgeseite von Audacity]
|{{Deutsch}}
|Ein einfaches, freies Programm um Sounddateien zu bearbeiten. Man kann es auch nutzen um Soundeffekte neu zu erstellen, indem man z.B. ein Geräusch mit dem Mikrofon aufnimmt und einige Effekt anwendet, um es passender und nicht mehr aufgenommen klingen zu lassen.
|-
|[http://lmms.sourceforge.net/ LMMS]
|{{Englisch}}
|LMMS (Linux MultiMedia Studio) ist ein OpenSource+Freeware Composer-Programm ähnlich zum bekannteren aber auch teuren CuBase(r). Trotz des Namens auch für Windows erhältlich.
|}

Link

2011-08-13T17:54:36Z

Lord horazont: /* Texturen */ Komm-Spalte hinzugefügt

Diese Linksammlung soll allgemeine Links zu unterschiedlichen Themen bieten, die mit der Multimediaentwicklung zu tun haben.
{{Hinweis|Vielleicht ist eine Zusammenführung mit [[Tool]] sinnvoll!}}
{{Hinweis|Vielleicht ist eine Aufteilung in Unterseiten sinnvoll (möglicherweise mit Kategorien)}}

= Entwicklung mit OpenGL =

== Hardwareinfos ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://delphi3d.net/hardware/listreports.php OpenGL Hardware Registry - Hardwareübersicht]
|{{Englisch}}
|Eine Datenbank aller Grafikkarten die in der Harware Registry vorhanden sind. Die einzelnen Artikel enthalten Infos darüber, welche Extensions von der Grafikkarte unterstützt werden.
|-
|[http://delphi3d.net/hardware/allexts.php OpenGL Hardware Registry - Extensionübersicht]
|{{Englisch}}
|Eine Datenbank aller Extensions die in der Harware Registry vorhanden sind. Die einzelnen Artikel enthalten Infos darüber, welche Grafikkarten die entsprechende Extension unterstützen.
|-
|}

== Tutorials ==

{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
||[[Tutorial|DGL Wiki - Tutorial]]
|{{Deutsch}}
|DelphiGL.com ist Betreiber dieses Wikis und stellt eine Vielzahl Tutorials mit Schwehrpunkt OpenGL zur Verfügung.
Neben Tutorials für Einsteiger und OpenGL Anfänger gibt es auch fortgeschrittene Themen wie Shader oder Partikelsysteme.Sprache der Wahl ist hier Delphi.
|-
|[http://www.joachimrohde.com/cms/xoops/modules/articles/index.php?cat_id=1 joachimrohde.com]
|{{Deutsch}}
|Auf dieser Seite findet ihr deutsche Übersetzungen der bekannten NeHe Tutorials. Sprache der Wahl ist hier C++.
|-
|[http://www.cg.tuwien.ac.at/studentwork/VRSem96/OpenGL/ Technische Universität Wien]
|{{Deutsch}}
|
|-
|[http://nehe.gamedev.net/ Nehe]
|{{Englisch}}
|Die berühmt berüchtigten NeHe Tutorials sind eine umfangreiche Sammlung an Tutorials zum Thema OpenGL. Von Anfängertutorials bis hin zu komplexen Effekten wird alles behandelt. Sprache der Wahl ist hier C++. (Eine Übersetzung der NeHe Tutorials findet ihr bei Joachim Rhode (siehe oben). )
|-
|[http://www.sulaco.co.za/tut.htm sulaco.co.za]
|{{Englisch}}
| OpenGL Beispiele in Delphi
|}

== OpenGL Funktionen ==

=== GL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GL|DGL Wiki - Kategorie GL]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten OpenGL Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL.tar.gz OpenGL.org - Orginal Spezifkationen]
|{{Englisch}}
|Die Orginalspezifikationen der OpenGL 1.0 und OpenGL 1.1 Befehle. (Diese HTML-Dokumente sind nicht Copy&Paste freundlich, da sie vermutlich automatisch aus vorhandenen Dateien (Postscript) erzeugt wurden.)
|-
|[http://developer.3dlabs.com/documents/glmanpage_index.htm 3dLabs]
|{{Englisch}}
|Die Orginalspezifikationen der OpenGL 1.0 und OpenGL 1.1 Befehle.
|-
|[http://www.mevis.de/~uwe/opengl/opengl.html mevis.de]
|{{Englisch}}
|Sammlung von Englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|[http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/glfunc01_4f03.asp MSDN von Microsoft]
|{{Englisch}}
|OpenGL Dokumentation in der MSDN. Die Erklärung der MSDN sind meist keine reinen Kopien der Orginalspezifikationen, sondern enthalten hin und wieder auch zusätzliche Informationen, oder formulieren Texte auf verständlichere Art und Weise.
|-
|}

=== GLU ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GLU|DGL Wiki - Kategorie GLU]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten GLU Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/glu/ OpenGL.org - Orginal Spezifkationen]
|{{Englisch}}
|Orginalspezifikationen für die GLU Befehle. (Diese HTML-Dokumente sind nicht Copy&Paste freundlich, da sie vermutlich automatisch aus vorhandenen Dateien (Postscript) erzeugt wurden.)
|-
|[http://www.mevis.de/~uwe/opengl/opengl.html mevis.de]
|{{Englisch}}
|Sammlung von englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|[http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/glufnc01_0e43.asp MSDN von Microsoft]
|{{Englisch}}
|GLU Dokumentation in der MSDN. Die Erklärung der MSDN sind meist keine reinen Kopien der Orginalspezifikationen, sondern enthalten hin und wieder auch zusätzliche Informationen, oder formulieren Texte auf verständlichere Art und Weise.
|-
|}

=== GLX ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GLX|DGL Wiki - Kategorie GLX]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten GLX Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/glx/ OpenGL.org - Orginal Spezifkationen]
|{{Englisch}}
|Orgninalspezifikationen der GLX Befehle bei OpenGL.org.
|-
|[http://www.mevis.de/~uwe/opengl/opengl.html mevis.de]
|{{Englisch}}
|Sammlung von Englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|}

=== WGL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:WGL|DGL Wiki - Kategorie WGL]]
|{{Deutsch}}
|Wiki-Kategorie die alle übersetzten WGL Befehle enthält.
|-
|[http://developer.3dlabs.com/documents/wglmanpage_index.htm 3dLabs]
|{{Englisch}}
|Sammlung einiger WGL Befehlsspezifikationen.
|-
|}

=== GLUT ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://freeglut.sourceforge.net/docs/api.php The freeglut Projekt]
|{{Englisch}}
|Englischsprachige Dokumentation zum OpenGL Utility Toolkit kurz GLUT.
|-
|}

=== SDL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:SDL|DGL Wiki - Kategorie SDL]]
|{{Deutsch}}
|Übersicht aller auf die SDL bezogenen Artikel hier im Wiki. Darunter befinden sich eine Vielzahl von Übersetzungen der SDL Befehlspezifikationen. Diese können auch in der [[SDL-Funktionsübersicht]] gefunden werden.
|-
|[http://www.libsdl.org/cgi/docwiki.cgi/SDL_20API libsdl.org]
|{{Englisch}}
|Das Dokumentationswiki von libSDL.org enthält die komplette Dokumenation zur SDL in englischer Sprache.
|-
|-
|[http://www.fp.sdl.de.vu/ fp.sdl.de.vu]
|{{Englisch}}
| Eine Webseite die speziell Informationen über die Programmierung von SDL unter Freepascal zur Verfügung stellt.
|-
|}

== FAQs ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[FAQ| DGL Wiki - FAQ]]
|{{Deutsch}}
|Ein FAQ (Frequently Asked Questions = Häufig gestellte Fragen) zu DelphiGL.com und dem DGL Wiki.
|-
|[http://www.3dsource.de/faq/index.htm 3dsource.de]
|{{Deutsch}}
|Ein FAQ zu Fragen rund um OpenGL.
|-
|}

== Effekte und Techniken mit OpenGL ==

===Glow===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamasutra.com/view/feature/2107/realtime_glow.php Gamasutra]
|{{Englisch}}
|Beschreibt, wie man mit Hilfe von Shader(hier DirectX Shader) den Gloweffekt in Realtime umsetzt. Dabei wird erst die Technik dahinter erklährt, und dann wie man sie Schritt für Schritt umsetzt.
|-
|[http://collective.valve-erc.com/index.php?go=tron1 valve-erc.com]
|{{Englisch}}
|Schritt für Schritt Anleitung, wie man mit Hilfe von Cg in OpenGL den Glow Effekt realisieren kann
|-
|}

===HDR===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamedev.net/columns/hardcore/hdrrendering/ gamedev.net]
|{{Englisch}}
|Hier wird sehr kurz eingeleitet, was HDR Rendering überhaupt ist, dann wird der Aufbau des *.hdr Formats erläutert, und dann geht es schon von 0 auf 100 zum Programmieren. Erklährungen gibt es kaum, dafür werden fertige Shader(für DirectX) geboten.
|-
|[http://www.gamedev.net/reference/articles/article2208.asp gamedev.net]
|{{Englisch}}
|Beschreibt auch nur etwas kurz das HDR Verfahren, jedoch mit mehr mathematischen Hintergrund in Sachen Tonemapping. Beispielcode für Tonemapping in C++ liegt bei.
|-
|}

===BSP Bäume===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.3dtechdev.com/tutorials/leafbsp/3dbsptrees.html 3dtechdev.com]
|{{Englisch}}
|Das beste Dokument überhaupt, für allem die selber BSP Bäume compilieren möchte. Ist belegt mit sehr viel Grafik. Erst beginnt er das Prinzip allgemein zum umschreiben, dann wird alles genau erläutert, und mit verständlichen Pseudocode untermalt.
|-
|[http://www.3dtechdev.com/tutorials/illegalgeometry/illegalgeometrytut.html 3dtechdev.com]
|{{Englisch}}
|Nicht ganz so gut geworden, wie sein erstes Tutorial, aber erklährt auch sehr gut, wie man illegale Geometrie aufspürt und beseitigt. Wieder mit Grafiken und Pseudocodes verständlich belegt. Hiermit kann man seinem Map-Compiler den letzten Schliff verleien.
|-
|[http://www.gamedev.net/reference/articles/article981.asp Gamedev]
|{{Englisch}}
|Von Michael Abrash, dürfte der ''Erfinder'' von Quake sein. Naja, meine Englischkenntnisse reichen hier nicht ganz aus, um den Text zu verstehen. Ist etwas umständlich geschrieben. Dafür mit Grafiken unterlegt.
|-
|[http://www.zfx-online.de/Tutorials.php?ID=11 Part 1 - Allgemein]
|{{Deutsch}}
|Einzigste deutsche Referenz zu BSP Bäumen, dafür Daumen hoch. Ist aber nicht das Wahre: schlechter C Code, und ich hatte auch nicht den Einduck, das er die Theorie zu diesem Thema bis in die Tiefe verstanden hat(oder er wollte es nicht zu akademisch Erklähren oO). Aber ein guter Einstieg in dieses Thema.
|-
|[http://www.zfx-online.de/Tutorials.php?ID=13 Part 2 - Kollision und PVS]
|{{Deutsch}}
|-
|[http://www.cs.uwec.edu/~stevende/cs455/programs/GameTutorials%20-%20Quake%203%20BSP%20Format.htm Quake3 *.bsp Format]
|{{Englisch}}
|Die beste Dokumentation für das BSP Format, die ich gefunden habe, besser als den Quake3 Sourcecode zu durchforsten. Leider etwas magere Eklährung zu wichtigen Themen wie Patches(Curved Surfaces). Ich pers. hatte jetzt 1 1/2 Wochen gebraucht, um das *.bsp Format vollständig zu verstehen. Ist aber anscheinend die beste Format Dokumentation im Netz.
|-
|[http://www.flipcode.com/articles/article_q2bsp.shtml Quake2 *.bsp Format]
|{{Englisch}}
|Kann auch nur soviel sagen, wie beim Link zuvor. Es fehlen hier auch zum Teil Informationen. Man muss halt viel ausprobieren, und sich den Quake 2 Source zu Herzen nehmen, damit man es versteht.
|-
|}

===Himmel & Wolken===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamedev.net/community/forums/topic.asp?topic_id=86024 Gamedev]
|{{Englisch}}
|Guter Thread mit vielen Anregungen und Links.
|-
|[http://www.gamedev.net/community/forums/topic.asp?topic_id=135654 Gamedev]
|{{Englisch}}
|Hier wird die Diskussion zum obigen Link weitergeführt.
|-
|[http://freespace.virgin.net/hugo.elias/models/m_clouds.htm Plasma]
|{{Englisch}}
|Eine nette Idee um Plasma in Echtzeit zu generieren, und zu verändern. Leider nichts zum Shading.
|-
|[http://nis-lab.is.s.u-tokyo.ac.jp/~nis/cdrom/sig00_cloud.pdf 3D Wolken]
|{{Englisch}}
|Paper über generieren und rendern von 3 dimensionalen Wolken inklusive Schatten und Lichtstrahlen. Ich hab nur den Lichtstahlen-Algorithmus ausprobiert. Saulangsam aber sehr einfach zu implementieren. Einen Blick ist es auf jeden Fall wert.
|-
|[http://www.geocities.com/ngdash/whitepapers/skydomecolor.html Skydome]
|{{Englisch}}
|Wenn man mal schnell gute Farben für seinen Skydome braucht...
|}

===Terrain===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.flipcode.com/articles/article_geomipmaps.shtml FlipCode]
|{{Englisch}}
|Artikel zu Geomipmaping. Zummindest hab ich es hier zum ersten mal gesehen. Und es funzt ganz gut.
|-
|[http://www.vterrain.org Virtual Terrain Project]
|{{Englisch}}
|Eine Seite mit Links und Artikeln zu allem, was etwas mit Terrainrendering zu tun hat.
|-
|}

===Sonstiges===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[Materialsammlung]]
|{{Deutsch}}
|Sammlung von gängigen Parametern für [[glMaterial]] hier im Wiki.
|-
|[http://freespace.virgin.net/hugo.elias/radiosity/radiosity.htm Radiosity]
|{{Englisch}}
|Erklährt sehr schön die Funktionsweise von Radiosity, liefert Beispielcodes und ist recht gut illustriert.
|-
|[http://legion.gibbering.net/projectx/paper/shadow%20mapping/ Shadowmapping]
|{{Englisch}}
|Beschreibt das Trapezoidal Shadow Mapping - Verfahren für gerichte Lichter.
|-
|[http://www.flipcode.com/articles/article_generatingnames.shtml Namensgenerator]
|{{Englisch}}
|Per Zufallsgenrator Namen erzeugen, und nie wieder kreativ werden müssen.
|-
|[http://www.paulsprojects.net/tutorials/simplebump/simplebump.html Bumpmapping]
|{{Englisch}}
|Bumpmapping auf Lowend-Grakas. Damals war Bumpmapping noch was ganz tolles...
|-
|[http://www.paulsprojects.net/opengl/dpreflect/dpreflect.html Dot Product Reflect]
|{{Englisch}}
|zwar nur ne Demo, aber wenn man schon immer mal mit EMBM das Wasser aus Morrowind nachproggen wollte...
|-
|}

== Beispiele/Demos mit Quelltext ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.delphigl.de DelphiGL.de]
|{{Deutsch}}
| Hier finden sich besonders eindrucksvolle Newton Physik Demos. Meißtens sogar mit Quelltext.
|-
|[http://www.shadow3d.de.vu/ Shadow 3D]
|{{Deutsch}}
| Hier finden sich zwei Demos wie man Quake 3 Modelle lädt und eine glSlang Demo
|-
|[[Shadersammlung]] im DGL Wiki
|{{Deutsch}}
| Hier findet man freie Shadersourcen.
|-
|[http://www.humus.name Humus]
|{{Englisch}}
| Diverse eindrucksvolle Demos zu verschiedenen Techniken, häufig mit Quelltext in C (teilweise OpenGL / DirectX)
|}

== weitere Links ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www-user.tu-chemnitz.de/~pester/Lehre/CompGeo.pdf CompGeo.pdf]
|{{Deutsch}}
| Script "Einführung in die Computergeometrie" von Dr. Pester (TU-Chemnitz). Ideales Nachschlagewerk für die Mathematik die einem bei der Grafikprogrammierung so begegnet.
|-
|[http://www.robsite.de/ robsite.de]
|{{Deutsch}}
| Auf dieser riesigen Seite finden sich auch viele weitere Links über verschiedene Themen der 3D Programmierung.
|-
|[http://www.3dlinks.com/links.cfm?categoryid=3&subcategoryid=21 3dlinks.com]
|{{Englisch}}
| Diese Seite hat es sich zur Hauptaufgabe gemacht Links auf Seiten mit dem Thema 3D zu sammeln.
|-
|[http://www.two-kings.de/links.html two-kings.de]
|{{Englisch}}
| Sammlung diverser interessanter Links, vorallem auf Themen im gamedev-Forum verweisend.
|-
|[http://www.delgine.com Delgine.com]
|{{Englisch}}
| Heimat des freien 3D Modellers "DeleD", welcher in Delphi programmiert ist. Ihr findet dort auch Modellpackete, Texturpackete, Plugins und Hilfe bei der Programmierung von Delphi und OpenGL.
|}

= Spieleentwicklung =

==Allgemein==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.spieleprogrammierung.net/ Spieleprogrammierung - OpenGL - GLSL - OpenAL - KI - Animation - Spielephysik]
|{{Deutsch}}
|Auf dieser Seite findet Ihr Artikel, Tutorials und Programmbeispiele rund um das Thema Spieleprogrammierung. Programmiersprache ist hier C/C++.
|-
|[http://graphics-and-physics-framework.spieleprogrammierung.net/ OpenGL Graphics And Physics Framework]
|{{Deutsch}}
|Auf dieser Seite findet Ihr ein frei verfügbares OpenGL basiertes Grafik und Physik Framework (LGPL-Lizenz) samt zugehöriger Probammbeispiele. Programmiersprache ist hier C/C++.
|-
|[http://audio-framework.spieleprogrammierung.net/ OpenAL Audio Framework]
|{{Deutsch}}
|Auf dieser Seite findet Ihr ein frei verfügbares OpenAL Audio Framework (LGPL-Lizenz) samt zugehöriger Probammbeispiele. Unterstützt werden 3D Sounds, EFX (EAX Alternative) Reverb Effekte sowie Audio Streaming (Music and Voices). Programmiersprache ist hier C/C++.
|-
|[http://spieleentwicklung-im-web.spieleprogrammierung.net/ Spieleentwicklung im Web]
|{{Deutsch}}
|Auf dieser Seite findet Ihr Links (E-Books, Präsentationen, wissenschaftliche Arbeiten und Tutorials) zu verschiedenen Themengebieten der Spieleentwicklung.
|-
|}

==Kopierschutz==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://inner-smile.com/nocrack.phtml Inner-Smile.com]
|{{Englisch}}
| Seite mit Gedanken zum Thema "Wie schütze ich meine Programme vor Crackern". Falls die Seite nicht erreichbar ist hat Google noch ne [http://www.google.com/search?q=cache:hpqPT5G4WB0J:www.inner-smile.com/nocrack.phtml+http://inner-smile.com/nocrack.phtml&hl=de&gl=de&ct=clnk&cd=1 Version im Archiv].
|-
|}

== Künstliche Intelligenz ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.kbs.uni-hannover.de/Lehre/KI2/Presentationen/presentation9798/esprit/spieltheorie/spieltheorie.html Uni-Hannover - Spieltheorie]
|{{Deutsch}}
|Artikel über die Grundlagen von KI in Spielen.
|-
|[http://www.robsite.de/tutorials.php?tut=ki Robsite KI-Tutorials]
|{{Deutsch}}
| Sammlung von Texten zum Thema KI in Spielen. Beispiele sind meist in C++.
|-
|[http://ai-depot.com/ AI-Depot.com]
|{{Englisch}}
| Seite die sich ausschließlich mit KI in Spielen beschäftigt.
|-
|[http://www.ai-junkie.com/links.html AI-Junkie.com]
|{{Englisch}}
|Linkseite mit vielen KI relevanten Links. Die Seite AI-Junie selbst behandelt auch viele Themen rund um KI.
|-
|[http://www.aiwisdom.com/ AIWisdom.com]
|{{Englisch}}
|Seite die sich mit KIs in Spielen beschäftigt und sich zum Ziel gesetzt hat, alle Artikel zum Thema zu finden und zu Katalogisieren. Es gibt hier auch Artikel über die KIs bestehender Spiele.
|-
|[http://www.aiguru.com/ AIGuru.com]
|{{Englisch}}
|Newsseite zum Thema KI, Künstliches Leben, Hiernforschung, Robotik, Nanotechnologie - Halt alles was Spass macht.
|-
|[http://www.generation5.org/ Generation5.org]
|{{Englisch}}
|Seite über KI, Robotik, etc. . Leider scheint die Seite Probleme zu haben regelmäßig aktualisiert zu werden. Aber zumindest sollte man einige Artikel finden. Die werden ja nicht schlecht.
|-
|www.gameai.com
|{{Englisch}}
|''Wurde Januar 2010 als down gemeldet. Weiss irgendwer etwas genaueres?'' Seite zum Thema KI in Spielen. Soll wohl einen gewissen Stellenwert in der AI-Szene haben.
|-
|[http://www-i1.informatik.rwth-aachen.de/~algorithmus/algo19.php Algorithmus der Woche - Informatikjahr 2006]
|{{Deutsch}}
|Vielleicht schon etwas älter aber doch eine gute Anleitung um eine einfache Schach-KI zu erstellen.
|}

= Ressourcen =
In dieser Gruppe finden sich Links um die Ressourcen für Eure Projekte zu erstellen.

== Texturen / 2D-Grafiken ==

=== Texturen ===
{| width = "100%" {{Prettytable_B1}}
!width="20%"|Link
!width="10%"|Genre
!width="10%"|Lizenz
!width="5%"|GPL
!width="5%"|MPL
!width="5%"|OSS
!width="5%"|CSS
!width="5%"|Komm.
!width="35%"|Bemerkungen
|-
|url
|Futuristisch, Mittelalter, etc.
|CC-BY-SA, etc., gerne auch mit Direktlink auf die Lizenzseite, so vorhanden.
|ja/nein/?
|ja/nein/?
|ja/nein/?
|ja/nein/?
|ja/nein/?
|Alle Bilder sind von Käse
|}
'''Legende:'''
:'''Kostenpflichtige Seiten''' sind mit einem * zu '''kennzeichnen'''
:GPL: Kompatibel mit der GPL
:MPL: Kompatibel mit der MPL
:OSS: Verwendung in OpenSource Software nicht verboten
:CSS: Verwendung in ClosedSource Software nicht verboten
:Komm: Verwendung in kommerzieller Software nicht verboten

=== Texturerstellung ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://3d.diehlsworld.de/textures/index.htm 3d.diehlsworld.de]
|{{Deutsch}}
|Auf dieser Seite findet ihr kurze aber inhaltlich reiche Tutorials zu der Frage "Wie erstelle ich XXXXX-Texturen". Dabei reicht die Palette von Untergrundtexturen wie Gras, Sand , Fels und Wasser (und Kombinationen dieser) bis hin zu Blitzen und Partikeln. Als Programm wird hier Photoshop verwendet.
|-
|[http://www.gimps.de/gimp/textur-muster/ gimps.de]
|{{Deutsch}}
|Schritt für Schritt Anleitungen wie man mit Gimp verschiedene Texturen erstellt.
|-
|[http://cbt.k090999.de/gimp.php#texturen k090999.de]
|{{Deutsch}}
|Gimptutorials zum Erstellen verschiedene Texturen.
|}

== Modelle / 3D-Grafiken ==

=== Blender ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://blendpolis.de/f/viewtopic.php?t=5786 Blendpolis]
|{{Deutsch}}
| Ein Thread im Forum von [http://blendpolis.de Blendpolis] in dem '''sehr''' viele Tutorials aufgelistet sind
|-
|[http://blendpolis.de/f/article_cat.php?fldAuto=7 Blendpolis]
|{{Deutsch}}
| Eigentliche Tutorial Seite von [http://blendpolis.de Blendpolis] die Auswahl ist hier aber nicht so groß
|-
|[http://wikivid.com/index.php/Blender Blender at wikivid.com]
|{{Englisch}}
| Linksammlung von Blender Video Tutorials
|-
|[http://www.blender.org/education-help/tutorials/getting-started/ blender3d.org]
|{{Englisch}}
| Auch die Heimatseite von Blender bietet viele Tutorials unter anderm auch Video Tuorials
|-
|[http://www.Blenderunderground.com Blenderunderground]
|{{Englisch}}
| '''sehr gute''' Video-Tutorials
|}

== Sounds ==

===Musik===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.jamendo.com/ Jamendo.com]
|{{Englisch}}
|Viele Künstler stellen hier ihre Alben unter einer Creative Commons Lizenz online. Man kann dort die Künstler auch kontaktieren und fragen ob man ihre Musik nutzen kann. Taugt außerdem als Radio! ;)
|-
|[http://incompetech.com/m/c/royalty-free/ Incompetech.com]
|{{Englisch}}
|Viele sehr schön gemacht instrumentale Musik aus allen möglichen Genres. Sie ist frei verwenderbar, wenn man den Macher der Musik (Kevin MacLeod) in seinem Programm erwähnt. Aber das hat er auch verdient. Folgende Programme nutzen beispielsweise (auch) Musik von incompetech.com:
* OpenParty
|-
|}

===Soundeffekte===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.freesound.org/ freesound.org]
|{{Englisch}}
|Diverse Sounds unter [http://www.creativecommons.org/ CreativeCommons] Lizenzen.
|}

===Soundprogramme===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://audacity.sourceforge.net/?lang=de Sourceforgeseite von Audacity]
|{{Deutsch}}
|Ein einfaches, freies Programm um Sounddateien zu bearbeiten. Man kann es auch nutzen um Soundeffekte neu zu erstellen, indem man z.B. ein Geräusch mit dem Mikrofon aufnimmt und einige Effekt anwendet, um es passender und nicht mehr aufgenommen klingen zu lassen.
|-
|[http://lmms.sourceforge.net/ LMMS]
|{{Englisch}}
|LMMS (Linux MultiMedia Studio) ist ein OpenSource+Freeware Composer-Programm ähnlich zum bekannteren aber auch teuren CuBase(r). Trotz des Namens auch für Windows erhältlich.
|}

Link

2011-08-13T17:51:27Z

Lord horazont: /* Texturen / 2D-Grafiken */ Vorlage für Texturenlinks

Diese Linksammlung soll allgemeine Links zu unterschiedlichen Themen bieten, die mit der Multimediaentwicklung zu tun haben.
{{Hinweis|Vielleicht ist eine Zusammenführung mit [[Tool]] sinnvoll!}}
{{Hinweis|Vielleicht ist eine Aufteilung in Unterseiten sinnvoll (möglicherweise mit Kategorien)}}

= Entwicklung mit OpenGL =

== Hardwareinfos ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://delphi3d.net/hardware/listreports.php OpenGL Hardware Registry - Hardwareübersicht]
|{{Englisch}}
|Eine Datenbank aller Grafikkarten die in der Harware Registry vorhanden sind. Die einzelnen Artikel enthalten Infos darüber, welche Extensions von der Grafikkarte unterstützt werden.
|-
|[http://delphi3d.net/hardware/allexts.php OpenGL Hardware Registry - Extensionübersicht]
|{{Englisch}}
|Eine Datenbank aller Extensions die in der Harware Registry vorhanden sind. Die einzelnen Artikel enthalten Infos darüber, welche Grafikkarten die entsprechende Extension unterstützen.
|-
|}

== Tutorials ==

{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
||[[Tutorial|DGL Wiki - Tutorial]]
|{{Deutsch}}
|DelphiGL.com ist Betreiber dieses Wikis und stellt eine Vielzahl Tutorials mit Schwehrpunkt OpenGL zur Verfügung.
Neben Tutorials für Einsteiger und OpenGL Anfänger gibt es auch fortgeschrittene Themen wie Shader oder Partikelsysteme.Sprache der Wahl ist hier Delphi.
|-
|[http://www.joachimrohde.com/cms/xoops/modules/articles/index.php?cat_id=1 joachimrohde.com]
|{{Deutsch}}
|Auf dieser Seite findet ihr deutsche Übersetzungen der bekannten NeHe Tutorials. Sprache der Wahl ist hier C++.
|-
|[http://www.cg.tuwien.ac.at/studentwork/VRSem96/OpenGL/ Technische Universität Wien]
|{{Deutsch}}
|
|-
|[http://nehe.gamedev.net/ Nehe]
|{{Englisch}}
|Die berühmt berüchtigten NeHe Tutorials sind eine umfangreiche Sammlung an Tutorials zum Thema OpenGL. Von Anfängertutorials bis hin zu komplexen Effekten wird alles behandelt. Sprache der Wahl ist hier C++. (Eine Übersetzung der NeHe Tutorials findet ihr bei Joachim Rhode (siehe oben). )
|-
|[http://www.sulaco.co.za/tut.htm sulaco.co.za]
|{{Englisch}}
| OpenGL Beispiele in Delphi
|}

== OpenGL Funktionen ==

=== GL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GL|DGL Wiki - Kategorie GL]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten OpenGL Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL.tar.gz OpenGL.org - Orginal Spezifkationen]
|{{Englisch}}
|Die Orginalspezifikationen der OpenGL 1.0 und OpenGL 1.1 Befehle. (Diese HTML-Dokumente sind nicht Copy&Paste freundlich, da sie vermutlich automatisch aus vorhandenen Dateien (Postscript) erzeugt wurden.)
|-
|[http://developer.3dlabs.com/documents/glmanpage_index.htm 3dLabs]
|{{Englisch}}
|Die Orginalspezifikationen der OpenGL 1.0 und OpenGL 1.1 Befehle.
|-
|[http://www.mevis.de/~uwe/opengl/opengl.html mevis.de]
|{{Englisch}}
|Sammlung von Englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|[http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/glfunc01_4f03.asp MSDN von Microsoft]
|{{Englisch}}
|OpenGL Dokumentation in der MSDN. Die Erklärung der MSDN sind meist keine reinen Kopien der Orginalspezifikationen, sondern enthalten hin und wieder auch zusätzliche Informationen, oder formulieren Texte auf verständlichere Art und Weise.
|-
|}

=== GLU ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GLU|DGL Wiki - Kategorie GLU]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten GLU Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/glu/ OpenGL.org - Orginal Spezifkationen]
|{{Englisch}}
|Orginalspezifikationen für die GLU Befehle. (Diese HTML-Dokumente sind nicht Copy&Paste freundlich, da sie vermutlich automatisch aus vorhandenen Dateien (Postscript) erzeugt wurden.)
|-
|[http://www.mevis.de/~uwe/opengl/opengl.html mevis.de]
|{{Englisch}}
|Sammlung von englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|[http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/glufnc01_0e43.asp MSDN von Microsoft]
|{{Englisch}}
|GLU Dokumentation in der MSDN. Die Erklärung der MSDN sind meist keine reinen Kopien der Orginalspezifikationen, sondern enthalten hin und wieder auch zusätzliche Informationen, oder formulieren Texte auf verständlichere Art und Weise.
|-
|}

=== GLX ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GLX|DGL Wiki - Kategorie GLX]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten GLX Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/glx/ OpenGL.org - Orginal Spezifkationen]
|{{Englisch}}
|Orgninalspezifikationen der GLX Befehle bei OpenGL.org.
|-
|[http://www.mevis.de/~uwe/opengl/opengl.html mevis.de]
|{{Englisch}}
|Sammlung von Englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|}

=== WGL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:WGL|DGL Wiki - Kategorie WGL]]
|{{Deutsch}}
|Wiki-Kategorie die alle übersetzten WGL Befehle enthält.
|-
|[http://developer.3dlabs.com/documents/wglmanpage_index.htm 3dLabs]
|{{Englisch}}
|Sammlung einiger WGL Befehlsspezifikationen.
|-
|}

=== GLUT ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://freeglut.sourceforge.net/docs/api.php The freeglut Projekt]
|{{Englisch}}
|Englischsprachige Dokumentation zum OpenGL Utility Toolkit kurz GLUT.
|-
|}

=== SDL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:SDL|DGL Wiki - Kategorie SDL]]
|{{Deutsch}}
|Übersicht aller auf die SDL bezogenen Artikel hier im Wiki. Darunter befinden sich eine Vielzahl von Übersetzungen der SDL Befehlspezifikationen. Diese können auch in der [[SDL-Funktionsübersicht]] gefunden werden.
|-
|[http://www.libsdl.org/cgi/docwiki.cgi/SDL_20API libsdl.org]
|{{Englisch}}
|Das Dokumentationswiki von libSDL.org enthält die komplette Dokumenation zur SDL in englischer Sprache.
|-
|-
|[http://www.fp.sdl.de.vu/ fp.sdl.de.vu]
|{{Englisch}}
| Eine Webseite die speziell Informationen über die Programmierung von SDL unter Freepascal zur Verfügung stellt.
|-
|}

== FAQs ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[FAQ| DGL Wiki - FAQ]]
|{{Deutsch}}
|Ein FAQ (Frequently Asked Questions = Häufig gestellte Fragen) zu DelphiGL.com und dem DGL Wiki.
|-
|[http://www.3dsource.de/faq/index.htm 3dsource.de]
|{{Deutsch}}
|Ein FAQ zu Fragen rund um OpenGL.
|-
|}

== Effekte und Techniken mit OpenGL ==

===Glow===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamasutra.com/view/feature/2107/realtime_glow.php Gamasutra]
|{{Englisch}}
|Beschreibt, wie man mit Hilfe von Shader(hier DirectX Shader) den Gloweffekt in Realtime umsetzt. Dabei wird erst die Technik dahinter erklährt, und dann wie man sie Schritt für Schritt umsetzt.
|-
|[http://collective.valve-erc.com/index.php?go=tron1 valve-erc.com]
|{{Englisch}}
|Schritt für Schritt Anleitung, wie man mit Hilfe von Cg in OpenGL den Glow Effekt realisieren kann
|-
|}

===HDR===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamedev.net/columns/hardcore/hdrrendering/ gamedev.net]
|{{Englisch}}
|Hier wird sehr kurz eingeleitet, was HDR Rendering überhaupt ist, dann wird der Aufbau des *.hdr Formats erläutert, und dann geht es schon von 0 auf 100 zum Programmieren. Erklährungen gibt es kaum, dafür werden fertige Shader(für DirectX) geboten.
|-
|[http://www.gamedev.net/reference/articles/article2208.asp gamedev.net]
|{{Englisch}}
|Beschreibt auch nur etwas kurz das HDR Verfahren, jedoch mit mehr mathematischen Hintergrund in Sachen Tonemapping. Beispielcode für Tonemapping in C++ liegt bei.
|-
|}

===BSP Bäume===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.3dtechdev.com/tutorials/leafbsp/3dbsptrees.html 3dtechdev.com]
|{{Englisch}}
|Das beste Dokument überhaupt, für allem die selber BSP Bäume compilieren möchte. Ist belegt mit sehr viel Grafik. Erst beginnt er das Prinzip allgemein zum umschreiben, dann wird alles genau erläutert, und mit verständlichen Pseudocode untermalt.
|-
|[http://www.3dtechdev.com/tutorials/illegalgeometry/illegalgeometrytut.html 3dtechdev.com]
|{{Englisch}}
|Nicht ganz so gut geworden, wie sein erstes Tutorial, aber erklährt auch sehr gut, wie man illegale Geometrie aufspürt und beseitigt. Wieder mit Grafiken und Pseudocodes verständlich belegt. Hiermit kann man seinem Map-Compiler den letzten Schliff verleien.
|-
|[http://www.gamedev.net/reference/articles/article981.asp Gamedev]
|{{Englisch}}
|Von Michael Abrash, dürfte der ''Erfinder'' von Quake sein. Naja, meine Englischkenntnisse reichen hier nicht ganz aus, um den Text zu verstehen. Ist etwas umständlich geschrieben. Dafür mit Grafiken unterlegt.
|-
|[http://www.zfx-online.de/Tutorials.php?ID=11 Part 1 - Allgemein]
|{{Deutsch}}
|Einzigste deutsche Referenz zu BSP Bäumen, dafür Daumen hoch. Ist aber nicht das Wahre: schlechter C Code, und ich hatte auch nicht den Einduck, das er die Theorie zu diesem Thema bis in die Tiefe verstanden hat(oder er wollte es nicht zu akademisch Erklähren oO). Aber ein guter Einstieg in dieses Thema.
|-
|[http://www.zfx-online.de/Tutorials.php?ID=13 Part 2 - Kollision und PVS]
|{{Deutsch}}
|-
|[http://www.cs.uwec.edu/~stevende/cs455/programs/GameTutorials%20-%20Quake%203%20BSP%20Format.htm Quake3 *.bsp Format]
|{{Englisch}}
|Die beste Dokumentation für das BSP Format, die ich gefunden habe, besser als den Quake3 Sourcecode zu durchforsten. Leider etwas magere Eklährung zu wichtigen Themen wie Patches(Curved Surfaces). Ich pers. hatte jetzt 1 1/2 Wochen gebraucht, um das *.bsp Format vollständig zu verstehen. Ist aber anscheinend die beste Format Dokumentation im Netz.
|-
|[http://www.flipcode.com/articles/article_q2bsp.shtml Quake2 *.bsp Format]
|{{Englisch}}
|Kann auch nur soviel sagen, wie beim Link zuvor. Es fehlen hier auch zum Teil Informationen. Man muss halt viel ausprobieren, und sich den Quake 2 Source zu Herzen nehmen, damit man es versteht.
|-
|}

===Himmel & Wolken===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamedev.net/community/forums/topic.asp?topic_id=86024 Gamedev]
|{{Englisch}}
|Guter Thread mit vielen Anregungen und Links.
|-
|[http://www.gamedev.net/community/forums/topic.asp?topic_id=135654 Gamedev]
|{{Englisch}}
|Hier wird die Diskussion zum obigen Link weitergeführt.
|-
|[http://freespace.virgin.net/hugo.elias/models/m_clouds.htm Plasma]
|{{Englisch}}
|Eine nette Idee um Plasma in Echtzeit zu generieren, und zu verändern. Leider nichts zum Shading.
|-
|[http://nis-lab.is.s.u-tokyo.ac.jp/~nis/cdrom/sig00_cloud.pdf 3D Wolken]
|{{Englisch}}
|Paper über generieren und rendern von 3 dimensionalen Wolken inklusive Schatten und Lichtstrahlen. Ich hab nur den Lichtstahlen-Algorithmus ausprobiert. Saulangsam aber sehr einfach zu implementieren. Einen Blick ist es auf jeden Fall wert.
|-
|[http://www.geocities.com/ngdash/whitepapers/skydomecolor.html Skydome]
|{{Englisch}}
|Wenn man mal schnell gute Farben für seinen Skydome braucht...
|}

===Terrain===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.flipcode.com/articles/article_geomipmaps.shtml FlipCode]
|{{Englisch}}
|Artikel zu Geomipmaping. Zummindest hab ich es hier zum ersten mal gesehen. Und es funzt ganz gut.
|-
|[http://www.vterrain.org Virtual Terrain Project]
|{{Englisch}}
|Eine Seite mit Links und Artikeln zu allem, was etwas mit Terrainrendering zu tun hat.
|-
|}

===Sonstiges===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[Materialsammlung]]
|{{Deutsch}}
|Sammlung von gängigen Parametern für [[glMaterial]] hier im Wiki.
|-
|[http://freespace.virgin.net/hugo.elias/radiosity/radiosity.htm Radiosity]
|{{Englisch}}
|Erklährt sehr schön die Funktionsweise von Radiosity, liefert Beispielcodes und ist recht gut illustriert.
|-
|[http://legion.gibbering.net/projectx/paper/shadow%20mapping/ Shadowmapping]
|{{Englisch}}
|Beschreibt das Trapezoidal Shadow Mapping - Verfahren für gerichte Lichter.
|-
|[http://www.flipcode.com/articles/article_generatingnames.shtml Namensgenerator]
|{{Englisch}}
|Per Zufallsgenrator Namen erzeugen, und nie wieder kreativ werden müssen.
|-
|[http://www.paulsprojects.net/tutorials/simplebump/simplebump.html Bumpmapping]
|{{Englisch}}
|Bumpmapping auf Lowend-Grakas. Damals war Bumpmapping noch was ganz tolles...
|-
|[http://www.paulsprojects.net/opengl/dpreflect/dpreflect.html Dot Product Reflect]
|{{Englisch}}
|zwar nur ne Demo, aber wenn man schon immer mal mit EMBM das Wasser aus Morrowind nachproggen wollte...
|-
|}

== Beispiele/Demos mit Quelltext ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.delphigl.de DelphiGL.de]
|{{Deutsch}}
| Hier finden sich besonders eindrucksvolle Newton Physik Demos. Meißtens sogar mit Quelltext.
|-
|[http://www.shadow3d.de.vu/ Shadow 3D]
|{{Deutsch}}
| Hier finden sich zwei Demos wie man Quake 3 Modelle lädt und eine glSlang Demo
|-
|[[Shadersammlung]] im DGL Wiki
|{{Deutsch}}
| Hier findet man freie Shadersourcen.
|-
|[http://www.humus.name Humus]
|{{Englisch}}
| Diverse eindrucksvolle Demos zu verschiedenen Techniken, häufig mit Quelltext in C (teilweise OpenGL / DirectX)
|}

== weitere Links ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www-user.tu-chemnitz.de/~pester/Lehre/CompGeo.pdf CompGeo.pdf]
|{{Deutsch}}
| Script "Einführung in die Computergeometrie" von Dr. Pester (TU-Chemnitz). Ideales Nachschlagewerk für die Mathematik die einem bei der Grafikprogrammierung so begegnet.
|-
|[http://www.robsite.de/ robsite.de]
|{{Deutsch}}
| Auf dieser riesigen Seite finden sich auch viele weitere Links über verschiedene Themen der 3D Programmierung.
|-
|[http://www.3dlinks.com/links.cfm?categoryid=3&subcategoryid=21 3dlinks.com]
|{{Englisch}}
| Diese Seite hat es sich zur Hauptaufgabe gemacht Links auf Seiten mit dem Thema 3D zu sammeln.
|-
|[http://www.two-kings.de/links.html two-kings.de]
|{{Englisch}}
| Sammlung diverser interessanter Links, vorallem auf Themen im gamedev-Forum verweisend.
|-
|[http://www.delgine.com Delgine.com]
|{{Englisch}}
| Heimat des freien 3D Modellers "DeleD", welcher in Delphi programmiert ist. Ihr findet dort auch Modellpackete, Texturpackete, Plugins und Hilfe bei der Programmierung von Delphi und OpenGL.
|}

= Spieleentwicklung =

==Allgemein==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.spieleprogrammierung.net/ Spieleprogrammierung - OpenGL - GLSL - OpenAL - KI - Animation - Spielephysik]
|{{Deutsch}}
|Auf dieser Seite findet Ihr Artikel, Tutorials und Programmbeispiele rund um das Thema Spieleprogrammierung. Programmiersprache ist hier C/C++.
|-
|[http://graphics-and-physics-framework.spieleprogrammierung.net/ OpenGL Graphics And Physics Framework]
|{{Deutsch}}
|Auf dieser Seite findet Ihr ein frei verfügbares OpenGL basiertes Grafik und Physik Framework (LGPL-Lizenz) samt zugehöriger Probammbeispiele. Programmiersprache ist hier C/C++.
|-
|[http://audio-framework.spieleprogrammierung.net/ OpenAL Audio Framework]
|{{Deutsch}}
|Auf dieser Seite findet Ihr ein frei verfügbares OpenAL Audio Framework (LGPL-Lizenz) samt zugehöriger Probammbeispiele. Unterstützt werden 3D Sounds, EFX (EAX Alternative) Reverb Effekte sowie Audio Streaming (Music and Voices). Programmiersprache ist hier C/C++.
|-
|[http://spieleentwicklung-im-web.spieleprogrammierung.net/ Spieleentwicklung im Web]
|{{Deutsch}}
|Auf dieser Seite findet Ihr Links (E-Books, Präsentationen, wissenschaftliche Arbeiten und Tutorials) zu verschiedenen Themengebieten der Spieleentwicklung.
|-
|}

==Kopierschutz==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://inner-smile.com/nocrack.phtml Inner-Smile.com]
|{{Englisch}}
| Seite mit Gedanken zum Thema "Wie schütze ich meine Programme vor Crackern". Falls die Seite nicht erreichbar ist hat Google noch ne [http://www.google.com/search?q=cache:hpqPT5G4WB0J:www.inner-smile.com/nocrack.phtml+http://inner-smile.com/nocrack.phtml&hl=de&gl=de&ct=clnk&cd=1 Version im Archiv].
|-
|}

== Künstliche Intelligenz ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.kbs.uni-hannover.de/Lehre/KI2/Presentationen/presentation9798/esprit/spieltheorie/spieltheorie.html Uni-Hannover - Spieltheorie]
|{{Deutsch}}
|Artikel über die Grundlagen von KI in Spielen.
|-
|[http://www.robsite.de/tutorials.php?tut=ki Robsite KI-Tutorials]
|{{Deutsch}}
| Sammlung von Texten zum Thema KI in Spielen. Beispiele sind meist in C++.
|-
|[http://ai-depot.com/ AI-Depot.com]
|{{Englisch}}
| Seite die sich ausschließlich mit KI in Spielen beschäftigt.
|-
|[http://www.ai-junkie.com/links.html AI-Junkie.com]
|{{Englisch}}
|Linkseite mit vielen KI relevanten Links. Die Seite AI-Junie selbst behandelt auch viele Themen rund um KI.
|-
|[http://www.aiwisdom.com/ AIWisdom.com]
|{{Englisch}}
|Seite die sich mit KIs in Spielen beschäftigt und sich zum Ziel gesetzt hat, alle Artikel zum Thema zu finden und zu Katalogisieren. Es gibt hier auch Artikel über die KIs bestehender Spiele.
|-
|[http://www.aiguru.com/ AIGuru.com]
|{{Englisch}}
|Newsseite zum Thema KI, Künstliches Leben, Hiernforschung, Robotik, Nanotechnologie - Halt alles was Spass macht.
|-
|[http://www.generation5.org/ Generation5.org]
|{{Englisch}}
|Seite über KI, Robotik, etc. . Leider scheint die Seite Probleme zu haben regelmäßig aktualisiert zu werden. Aber zumindest sollte man einige Artikel finden. Die werden ja nicht schlecht.
|-
|www.gameai.com
|{{Englisch}}
|''Wurde Januar 2010 als down gemeldet. Weiss irgendwer etwas genaueres?'' Seite zum Thema KI in Spielen. Soll wohl einen gewissen Stellenwert in der AI-Szene haben.
|-
|[http://www-i1.informatik.rwth-aachen.de/~algorithmus/algo19.php Algorithmus der Woche - Informatikjahr 2006]
|{{Deutsch}}
|Vielleicht schon etwas älter aber doch eine gute Anleitung um eine einfache Schach-KI zu erstellen.
|}

= Ressourcen =
In dieser Gruppe finden sich Links um die Ressourcen für Eure Projekte zu erstellen.

== Texturen / 2D-Grafiken ==

=== Texturen ===
{| width = "100%" {{Prettytable_B1}}
!width="20%"|Link
!width="10%"|Genre
!width="10%"|Lizenz
!width="5%"|GPL
!width="5%"|MPL
!width="5%"|OSS
!width="5%"|CSS
!width="40%"|Bemerkungen
|-
|url
|Futuristisch, Mittelalter, etc.
|CC-BY-SA, etc., gerne auch mit Direktlink auf die Lizenzseite, so vorhanden.
|ja/nein/?
|ja/nein/?
|ja/nein/?
|ja/nein/?
|Alle Bilder sind von Käse
|}
'''Legende:'''
:'''Kostenpflichtige Seiten''' sind mit einem * zu '''kennzeichnen'''
:GPL: Kompatibel mit der GPL
:MPL: Kompatibel mit der MPL
:OSS: Verwendung in OpenSource Software nicht verboten
:CSS: Verwendung in ClosedSource Software nicht verboten

=== Texturerstellung ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://3d.diehlsworld.de/textures/index.htm 3d.diehlsworld.de]
|{{Deutsch}}
|Auf dieser Seite findet ihr kurze aber inhaltlich reiche Tutorials zu der Frage "Wie erstelle ich XXXXX-Texturen". Dabei reicht die Palette von Untergrundtexturen wie Gras, Sand , Fels und Wasser (und Kombinationen dieser) bis hin zu Blitzen und Partikeln. Als Programm wird hier Photoshop verwendet.
|-
|[http://www.gimps.de/gimp/textur-muster/ gimps.de]
|{{Deutsch}}
|Schritt für Schritt Anleitungen wie man mit Gimp verschiedene Texturen erstellt.
|-
|[http://cbt.k090999.de/gimp.php#texturen k090999.de]
|{{Deutsch}}
|Gimptutorials zum Erstellen verschiedene Texturen.
|}

== Modelle / 3D-Grafiken ==

=== Blender ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://blendpolis.de/f/viewtopic.php?t=5786 Blendpolis]
|{{Deutsch}}
| Ein Thread im Forum von [http://blendpolis.de Blendpolis] in dem '''sehr''' viele Tutorials aufgelistet sind
|-
|[http://blendpolis.de/f/article_cat.php?fldAuto=7 Blendpolis]
|{{Deutsch}}
| Eigentliche Tutorial Seite von [http://blendpolis.de Blendpolis] die Auswahl ist hier aber nicht so groß
|-
|[http://wikivid.com/index.php/Blender Blender at wikivid.com]
|{{Englisch}}
| Linksammlung von Blender Video Tutorials
|-
|[http://www.blender.org/education-help/tutorials/getting-started/ blender3d.org]
|{{Englisch}}
| Auch die Heimatseite von Blender bietet viele Tutorials unter anderm auch Video Tuorials
|-
|[http://www.Blenderunderground.com Blenderunderground]
|{{Englisch}}
| '''sehr gute''' Video-Tutorials
|}

== Sounds ==

===Musik===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.jamendo.com/ Jamendo.com]
|{{Englisch}}
|Viele Künstler stellen hier ihre Alben unter einer Creative Commons Lizenz online. Man kann dort die Künstler auch kontaktieren und fragen ob man ihre Musik nutzen kann. Taugt außerdem als Radio! ;)
|-
|[http://incompetech.com/m/c/royalty-free/ Incompetech.com]
|{{Englisch}}
|Viele sehr schön gemacht instrumentale Musik aus allen möglichen Genres. Sie ist frei verwenderbar, wenn man den Macher der Musik (Kevin MacLeod) in seinem Programm erwähnt. Aber das hat er auch verdient. Folgende Programme nutzen beispielsweise (auch) Musik von incompetech.com:
* OpenParty
|-
|}

===Soundeffekte===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.freesound.org/ freesound.org]
|{{Englisch}}
|Diverse Sounds unter [http://www.creativecommons.org/ CreativeCommons] Lizenzen.
|}

===Soundprogramme===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://audacity.sourceforge.net/?lang=de Sourceforgeseite von Audacity]
|{{Deutsch}}
|Ein einfaches, freies Programm um Sounddateien zu bearbeiten. Man kann es auch nutzen um Soundeffekte neu zu erstellen, indem man z.B. ein Geräusch mit dem Mikrofon aufnimmt und einige Effekt anwendet, um es passender und nicht mehr aufgenommen klingen zu lassen.
|-
|[http://lmms.sourceforge.net/ LMMS]
|{{Englisch}}
|LMMS (Linux MultiMedia Studio) ist ein OpenSource+Freeware Composer-Programm ähnlich zum bekannteren aber auch teuren CuBase(r). Trotz des Namens auch für Windows erhältlich.
|}

Link

2011-08-13T17:44:10Z

Lord horazont: Unvollständigen Upload reparieren (2/2)

Diese Linksammlung soll allgemeine Links zu unterschiedlichen Themen bieten, die mit der Multimediaentwicklung zu tun haben.
{{Hinweis|Vielleicht ist eine Zusammenführung mit [[Tool]] sinnvoll!}}
{{Hinweis|Vielleicht ist eine Aufteilung in Unterseiten sinnvoll (möglicherweise mit Kategorien)}}

= Entwicklung mit OpenGL =

== Hardwareinfos ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://delphi3d.net/hardware/listreports.php OpenGL Hardware Registry - Hardwareübersicht]
|{{Englisch}}
|Eine Datenbank aller Grafikkarten die in der Harware Registry vorhanden sind. Die einzelnen Artikel enthalten Infos darüber, welche Extensions von der Grafikkarte unterstützt werden.
|-
|[http://delphi3d.net/hardware/allexts.php OpenGL Hardware Registry - Extensionübersicht]
|{{Englisch}}
|Eine Datenbank aller Extensions die in der Harware Registry vorhanden sind. Die einzelnen Artikel enthalten Infos darüber, welche Grafikkarten die entsprechende Extension unterstützen.
|-
|}

== Tutorials ==

{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
||[[Tutorial|DGL Wiki - Tutorial]]
|{{Deutsch}}
|DelphiGL.com ist Betreiber dieses Wikis und stellt eine Vielzahl Tutorials mit Schwehrpunkt OpenGL zur Verfügung.
Neben Tutorials für Einsteiger und OpenGL Anfänger gibt es auch fortgeschrittene Themen wie Shader oder Partikelsysteme.Sprache der Wahl ist hier Delphi.
|-
|[http://www.joachimrohde.com/cms/xoops/modules/articles/index.php?cat_id=1 joachimrohde.com]
|{{Deutsch}}
|Auf dieser Seite findet ihr deutsche Übersetzungen der bekannten NeHe Tutorials. Sprache der Wahl ist hier C++.
|-
|[http://www.cg.tuwien.ac.at/studentwork/VRSem96/OpenGL/ Technische Universität Wien]
|{{Deutsch}}
|
|-
|[http://nehe.gamedev.net/ Nehe]
|{{Englisch}}
|Die berühmt berüchtigten NeHe Tutorials sind eine umfangreiche Sammlung an Tutorials zum Thema OpenGL. Von Anfängertutorials bis hin zu komplexen Effekten wird alles behandelt. Sprache der Wahl ist hier C++. (Eine Übersetzung der NeHe Tutorials findet ihr bei Joachim Rhode (siehe oben). )
|-
|[http://www.sulaco.co.za/tut.htm sulaco.co.za]
|{{Englisch}}
| OpenGL Beispiele in Delphi
|}

== OpenGL Funktionen ==

=== GL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GL|DGL Wiki - Kategorie GL]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten OpenGL Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL.tar.gz OpenGL.org - Orginal Spezifkationen]
|{{Englisch}}
|Die Orginalspezifikationen der OpenGL 1.0 und OpenGL 1.1 Befehle. (Diese HTML-Dokumente sind nicht Copy&Paste freundlich, da sie vermutlich automatisch aus vorhandenen Dateien (Postscript) erzeugt wurden.)
|-
|[http://developer.3dlabs.com/documents/glmanpage_index.htm 3dLabs]
|{{Englisch}}
|Die Orginalspezifikationen der OpenGL 1.0 und OpenGL 1.1 Befehle.
|-
|[http://www.mevis.de/~uwe/opengl/opengl.html mevis.de]
|{{Englisch}}
|Sammlung von Englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|[http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/glfunc01_4f03.asp MSDN von Microsoft]
|{{Englisch}}
|OpenGL Dokumentation in der MSDN. Die Erklärung der MSDN sind meist keine reinen Kopien der Orginalspezifikationen, sondern enthalten hin und wieder auch zusätzliche Informationen, oder formulieren Texte auf verständlichere Art und Weise.
|-
|}

=== GLU ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GLU|DGL Wiki - Kategorie GLU]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten GLU Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/glu/ OpenGL.org - Orginal Spezifkationen]
|{{Englisch}}
|Orginalspezifikationen für die GLU Befehle. (Diese HTML-Dokumente sind nicht Copy&Paste freundlich, da sie vermutlich automatisch aus vorhandenen Dateien (Postscript) erzeugt wurden.)
|-
|[http://www.mevis.de/~uwe/opengl/opengl.html mevis.de]
|{{Englisch}}
|Sammlung von englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|[http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/glufnc01_0e43.asp MSDN von Microsoft]
|{{Englisch}}
|GLU Dokumentation in der MSDN. Die Erklärung der MSDN sind meist keine reinen Kopien der Orginalspezifikationen, sondern enthalten hin und wieder auch zusätzliche Informationen, oder formulieren Texte auf verständlichere Art und Weise.
|-
|}

=== GLX ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GLX|DGL Wiki - Kategorie GLX]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten GLX Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/glx/ OpenGL.org - Orginal Spezifkationen]
|{{Englisch}}
|Orgninalspezifikationen der GLX Befehle bei OpenGL.org.
|-
|[http://www.mevis.de/~uwe/opengl/opengl.html mevis.de]
|{{Englisch}}
|Sammlung von Englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|}

=== WGL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:WGL|DGL Wiki - Kategorie WGL]]
|{{Deutsch}}
|Wiki-Kategorie die alle übersetzten WGL Befehle enthält.
|-
|[http://developer.3dlabs.com/documents/wglmanpage_index.htm 3dLabs]
|{{Englisch}}
|Sammlung einiger WGL Befehlsspezifikationen.
|-
|}

=== GLUT ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://freeglut.sourceforge.net/docs/api.php The freeglut Projekt]
|{{Englisch}}
|Englischsprachige Dokumentation zum OpenGL Utility Toolkit kurz GLUT.
|-
|}

=== SDL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:SDL|DGL Wiki - Kategorie SDL]]
|{{Deutsch}}
|Übersicht aller auf die SDL bezogenen Artikel hier im Wiki. Darunter befinden sich eine Vielzahl von Übersetzungen der SDL Befehlspezifikationen. Diese können auch in der [[SDL-Funktionsübersicht]] gefunden werden.
|-
|[http://www.libsdl.org/cgi/docwiki.cgi/SDL_20API libsdl.org]
|{{Englisch}}
|Das Dokumentationswiki von libSDL.org enthält die komplette Dokumenation zur SDL in englischer Sprache.
|-
|-
|[http://www.fp.sdl.de.vu/ fp.sdl.de.vu]
|{{Englisch}}
| Eine Webseite die speziell Informationen über die Programmierung von SDL unter Freepascal zur Verfügung stellt.
|-
|}

== FAQs ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[FAQ| DGL Wiki - FAQ]]
|{{Deutsch}}
|Ein FAQ (Frequently Asked Questions = Häufig gestellte Fragen) zu DelphiGL.com und dem DGL Wiki.
|-
|[http://www.3dsource.de/faq/index.htm 3dsource.de]
|{{Deutsch}}
|Ein FAQ zu Fragen rund um OpenGL.
|-
|}

== Effekte und Techniken mit OpenGL ==

===Glow===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamasutra.com/view/feature/2107/realtime_glow.php Gamasutra]
|{{Englisch}}
|Beschreibt, wie man mit Hilfe von Shader(hier DirectX Shader) den Gloweffekt in Realtime umsetzt. Dabei wird erst die Technik dahinter erklährt, und dann wie man sie Schritt für Schritt umsetzt.
|-
|[http://collective.valve-erc.com/index.php?go=tron1 valve-erc.com]
|{{Englisch}}
|Schritt für Schritt Anleitung, wie man mit Hilfe von Cg in OpenGL den Glow Effekt realisieren kann
|-
|}

===HDR===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamedev.net/columns/hardcore/hdrrendering/ gamedev.net]
|{{Englisch}}
|Hier wird sehr kurz eingeleitet, was HDR Rendering überhaupt ist, dann wird der Aufbau des *.hdr Formats erläutert, und dann geht es schon von 0 auf 100 zum Programmieren. Erklährungen gibt es kaum, dafür werden fertige Shader(für DirectX) geboten.
|-
|[http://www.gamedev.net/reference/articles/article2208.asp gamedev.net]
|{{Englisch}}
|Beschreibt auch nur etwas kurz das HDR Verfahren, jedoch mit mehr mathematischen Hintergrund in Sachen Tonemapping. Beispielcode für Tonemapping in C++ liegt bei.
|-
|}

===BSP Bäume===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.3dtechdev.com/tutorials/leafbsp/3dbsptrees.html 3dtechdev.com]
|{{Englisch}}
|Das beste Dokument überhaupt, für allem die selber BSP Bäume compilieren möchte. Ist belegt mit sehr viel Grafik. Erst beginnt er das Prinzip allgemein zum umschreiben, dann wird alles genau erläutert, und mit verständlichen Pseudocode untermalt.
|-
|[http://www.3dtechdev.com/tutorials/illegalgeometry/illegalgeometrytut.html 3dtechdev.com]
|{{Englisch}}
|Nicht ganz so gut geworden, wie sein erstes Tutorial, aber erklährt auch sehr gut, wie man illegale Geometrie aufspürt und beseitigt. Wieder mit Grafiken und Pseudocodes verständlich belegt. Hiermit kann man seinem Map-Compiler den letzten Schliff verleien.
|-
|[http://www.gamedev.net/reference/articles/article981.asp Gamedev]
|{{Englisch}}
|Von Michael Abrash, dürfte der ''Erfinder'' von Quake sein. Naja, meine Englischkenntnisse reichen hier nicht ganz aus, um den Text zu verstehen. Ist etwas umständlich geschrieben. Dafür mit Grafiken unterlegt.
|-
|[http://www.zfx-online.de/Tutorials.php?ID=11 Part 1 - Allgemein]
|{{Deutsch}}
|Einzigste deutsche Referenz zu BSP Bäumen, dafür Daumen hoch. Ist aber nicht das Wahre: schlechter C Code, und ich hatte auch nicht den Einduck, das er die Theorie zu diesem Thema bis in die Tiefe verstanden hat(oder er wollte es nicht zu akademisch Erklähren oO). Aber ein guter Einstieg in dieses Thema.
|-
|[http://www.zfx-online.de/Tutorials.php?ID=13 Part 2 - Kollision und PVS]
|{{Deutsch}}
|-
|[http://www.cs.uwec.edu/~stevende/cs455/programs/GameTutorials%20-%20Quake%203%20BSP%20Format.htm Quake3 *.bsp Format]
|{{Englisch}}
|Die beste Dokumentation für das BSP Format, die ich gefunden habe, besser als den Quake3 Sourcecode zu durchforsten. Leider etwas magere Eklährung zu wichtigen Themen wie Patches(Curved Surfaces). Ich pers. hatte jetzt 1 1/2 Wochen gebraucht, um das *.bsp Format vollständig zu verstehen. Ist aber anscheinend die beste Format Dokumentation im Netz.
|-
|[http://www.flipcode.com/articles/article_q2bsp.shtml Quake2 *.bsp Format]
|{{Englisch}}
|Kann auch nur soviel sagen, wie beim Link zuvor. Es fehlen hier auch zum Teil Informationen. Man muss halt viel ausprobieren, und sich den Quake 2 Source zu Herzen nehmen, damit man es versteht.
|-
|}

===Himmel & Wolken===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamedev.net/community/forums/topic.asp?topic_id=86024 Gamedev]
|{{Englisch}}
|Guter Thread mit vielen Anregungen und Links.
|-
|[http://www.gamedev.net/community/forums/topic.asp?topic_id=135654 Gamedev]
|{{Englisch}}
|Hier wird die Diskussion zum obigen Link weitergeführt.
|-
|[http://freespace.virgin.net/hugo.elias/models/m_clouds.htm Plasma]
|{{Englisch}}
|Eine nette Idee um Plasma in Echtzeit zu generieren, und zu verändern. Leider nichts zum Shading.
|-
|[http://nis-lab.is.s.u-tokyo.ac.jp/~nis/cdrom/sig00_cloud.pdf 3D Wolken]
|{{Englisch}}
|Paper über generieren und rendern von 3 dimensionalen Wolken inklusive Schatten und Lichtstrahlen. Ich hab nur den Lichtstahlen-Algorithmus ausprobiert. Saulangsam aber sehr einfach zu implementieren. Einen Blick ist es auf jeden Fall wert.
|-
|[http://www.geocities.com/ngdash/whitepapers/skydomecolor.html Skydome]
|{{Englisch}}
|Wenn man mal schnell gute Farben für seinen Skydome braucht...
|}

===Terrain===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.flipcode.com/articles/article_geomipmaps.shtml FlipCode]
|{{Englisch}}
|Artikel zu Geomipmaping. Zummindest hab ich es hier zum ersten mal gesehen. Und es funzt ganz gut.
|-
|[http://www.vterrain.org Virtual Terrain Project]
|{{Englisch}}
|Eine Seite mit Links und Artikeln zu allem, was etwas mit Terrainrendering zu tun hat.
|-
|}

===Sonstiges===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[Materialsammlung]]
|{{Deutsch}}
|Sammlung von gängigen Parametern für [[glMaterial]] hier im Wiki.
|-
|[http://freespace.virgin.net/hugo.elias/radiosity/radiosity.htm Radiosity]
|{{Englisch}}
|Erklährt sehr schön die Funktionsweise von Radiosity, liefert Beispielcodes und ist recht gut illustriert.
|-
|[http://legion.gibbering.net/projectx/paper/shadow%20mapping/ Shadowmapping]
|{{Englisch}}
|Beschreibt das Trapezoidal Shadow Mapping - Verfahren für gerichte Lichter.
|-
|[http://www.flipcode.com/articles/article_generatingnames.shtml Namensgenerator]
|{{Englisch}}
|Per Zufallsgenrator Namen erzeugen, und nie wieder kreativ werden müssen.
|-
|[http://www.paulsprojects.net/tutorials/simplebump/simplebump.html Bumpmapping]
|{{Englisch}}
|Bumpmapping auf Lowend-Grakas. Damals war Bumpmapping noch was ganz tolles...
|-
|[http://www.paulsprojects.net/opengl/dpreflect/dpreflect.html Dot Product Reflect]
|{{Englisch}}
|zwar nur ne Demo, aber wenn man schon immer mal mit EMBM das Wasser aus Morrowind nachproggen wollte...
|-
|}

== Beispiele/Demos mit Quelltext ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.delphigl.de DelphiGL.de]
|{{Deutsch}}
| Hier finden sich besonders eindrucksvolle Newton Physik Demos. Meißtens sogar mit Quelltext.
|-
|[http://www.shadow3d.de.vu/ Shadow 3D]
|{{Deutsch}}
| Hier finden sich zwei Demos wie man Quake 3 Modelle lädt und eine glSlang Demo
|-
|[[Shadersammlung]] im DGL Wiki
|{{Deutsch}}
| Hier findet man freie Shadersourcen.
|-
|[http://www.humus.name Humus]
|{{Englisch}}
| Diverse eindrucksvolle Demos zu verschiedenen Techniken, häufig mit Quelltext in C (teilweise OpenGL / DirectX)
|}

== weitere Links ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www-user.tu-chemnitz.de/~pester/Lehre/CompGeo.pdf CompGeo.pdf]
|{{Deutsch}}
| Script "Einführung in die Computergeometrie" von Dr. Pester (TU-Chemnitz). Ideales Nachschlagewerk für die Mathematik die einem bei der Grafikprogrammierung so begegnet.
|-
|[http://www.robsite.de/ robsite.de]
|{{Deutsch}}
| Auf dieser riesigen Seite finden sich auch viele weitere Links über verschiedene Themen der 3D Programmierung.
|-
|[http://www.3dlinks.com/links.cfm?categoryid=3&subcategoryid=21 3dlinks.com]
|{{Englisch}}
| Diese Seite hat es sich zur Hauptaufgabe gemacht Links auf Seiten mit dem Thema 3D zu sammeln.
|-
|[http://www.two-kings.de/links.html two-kings.de]
|{{Englisch}}
| Sammlung diverser interessanter Links, vorallem auf Themen im gamedev-Forum verweisend.
|-
|[http://www.delgine.com Delgine.com]
|{{Englisch}}
| Heimat des freien 3D Modellers "DeleD", welcher in Delphi programmiert ist. Ihr findet dort auch Modellpackete, Texturpackete, Plugins und Hilfe bei der Programmierung von Delphi und OpenGL.
|}

= Spieleentwicklung =

==Allgemein==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.spieleprogrammierung.net/ Spieleprogrammierung - OpenGL - GLSL - OpenAL - KI - Animation - Spielephysik]
|{{Deutsch}}
|Auf dieser Seite findet Ihr Artikel, Tutorials und Programmbeispiele rund um das Thema Spieleprogrammierung. Programmiersprache ist hier C/C++.
|-
|[http://graphics-and-physics-framework.spieleprogrammierung.net/ OpenGL Graphics And Physics Framework]
|{{Deutsch}}
|Auf dieser Seite findet Ihr ein frei verfügbares OpenGL basiertes Grafik und Physik Framework (LGPL-Lizenz) samt zugehöriger Probammbeispiele. Programmiersprache ist hier C/C++.
|-
|[http://audio-framework.spieleprogrammierung.net/ OpenAL Audio Framework]
|{{Deutsch}}
|Auf dieser Seite findet Ihr ein frei verfügbares OpenAL Audio Framework (LGPL-Lizenz) samt zugehöriger Probammbeispiele. Unterstützt werden 3D Sounds, EFX (EAX Alternative) Reverb Effekte sowie Audio Streaming (Music and Voices). Programmiersprache ist hier C/C++.
|-
|[http://spieleentwicklung-im-web.spieleprogrammierung.net/ Spieleentwicklung im Web]
|{{Deutsch}}
|Auf dieser Seite findet Ihr Links (E-Books, Präsentationen, wissenschaftliche Arbeiten und Tutorials) zu verschiedenen Themengebieten der Spieleentwicklung.
|-
|}

==Kopierschutz==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://inner-smile.com/nocrack.phtml Inner-Smile.com]
|{{Englisch}}
| Seite mit Gedanken zum Thema "Wie schütze ich meine Programme vor Crackern". Falls die Seite nicht erreichbar ist hat Google noch ne [http://www.google.com/search?q=cache:hpqPT5G4WB0J:www.inner-smile.com/nocrack.phtml+http://inner-smile.com/nocrack.phtml&hl=de&gl=de&ct=clnk&cd=1 Version im Archiv].
|-
|}

== Künstliche Intelligenz ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.kbs.uni-hannover.de/Lehre/KI2/Presentationen/presentation9798/esprit/spieltheorie/spieltheorie.html Uni-Hannover - Spieltheorie]
|{{Deutsch}}
|Artikel über die Grundlagen von KI in Spielen.
|-
|[http://www.robsite.de/tutorials.php?tut=ki Robsite KI-Tutorials]
|{{Deutsch}}
| Sammlung von Texten zum Thema KI in Spielen. Beispiele sind meist in C++.
|-
|[http://ai-depot.com/ AI-Depot.com]
|{{Englisch}}
| Seite die sich ausschließlich mit KI in Spielen beschäftigt.
|-
|[http://www.ai-junkie.com/links.html AI-Junkie.com]
|{{Englisch}}
|Linkseite mit vielen KI relevanten Links. Die Seite AI-Junie selbst behandelt auch viele Themen rund um KI.
|-
|[http://www.aiwisdom.com/ AIWisdom.com]
|{{Englisch}}
|Seite die sich mit KIs in Spielen beschäftigt und sich zum Ziel gesetzt hat, alle Artikel zum Thema zu finden und zu Katalogisieren. Es gibt hier auch Artikel über die KIs bestehender Spiele.
|-
|[http://www.aiguru.com/ AIGuru.com]
|{{Englisch}}
|Newsseite zum Thema KI, Künstliches Leben, Hiernforschung, Robotik, Nanotechnologie - Halt alles was Spass macht.
|-
|[http://www.generation5.org/ Generation5.org]
|{{Englisch}}
|Seite über KI, Robotik, etc. . Leider scheint die Seite Probleme zu haben regelmäßig aktualisiert zu werden. Aber zumindest sollte man einige Artikel finden. Die werden ja nicht schlecht.
|-
|www.gameai.com
|{{Englisch}}
|''Wurde Januar 2010 als down gemeldet. Weiss irgendwer etwas genaueres?'' Seite zum Thema KI in Spielen. Soll wohl einen gewissen Stellenwert in der AI-Szene haben.
|-
|[http://www-i1.informatik.rwth-aachen.de/~algorithmus/algo19.php Algorithmus der Woche - Informatikjahr 2006]
|{{Deutsch}}
|Vielleicht schon etwas älter aber doch eine gute Anleitung um eine einfache Schach-KI zu erstellen.
|}

= Ressourcen =
In dieser Gruppe finden sich Links um die Ressourcen für Eure Projekte zu erstellen.

== Texturen / 2D-Grafiken ==

=== Texturerstellung ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://3d.diehlsworld.de/textures/index.htm 3d.diehlsworld.de]
|{{Deutsch}}
|Auf dieser Seite findet ihr kurze aber inhaltlich reiche Tutorials zu der Frage "Wie erstelle ich XXXXX-Texturen". Dabei reicht die Palette von Untergrundtexturen wie Gras, Sand , Fels und Wasser (und Kombinationen dieser) bis hin zu Blitzen und Partikeln. Als Programm wird hier Photoshop verwendet.
|-
|[http://www.gimps.de/gimp/textur-muster/ gimps.de]
|{{Deutsch}}
|Schritt für Schritt Anleitungen wie man mit Gimp verschiedene Texturen erstellt.
|-
|[http://cbt.k090999.de/gimp.php#texturen k090999.de]
|{{Deutsch}}
|Gimptutorials zum Erstellen verschiedene Texturen.
|}

== Modelle / 3D-Grafiken ==

=== Blender ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://blendpolis.de/f/viewtopic.php?t=5786 Blendpolis]
|{{Deutsch}}
| Ein Thread im Forum von [http://blendpolis.de Blendpolis] in dem '''sehr''' viele Tutorials aufgelistet sind
|-
|[http://blendpolis.de/f/article_cat.php?fldAuto=7 Blendpolis]
|{{Deutsch}}
| Eigentliche Tutorial Seite von [http://blendpolis.de Blendpolis] die Auswahl ist hier aber nicht so groß
|-
|[http://wikivid.com/index.php/Blender Blender at wikivid.com]
|{{Englisch}}
| Linksammlung von Blender Video Tutorials
|-
|[http://www.blender.org/education-help/tutorials/getting-started/ blender3d.org]
|{{Englisch}}
| Auch die Heimatseite von Blender bietet viele Tutorials unter anderm auch Video Tuorials
|-
|[http://www.Blenderunderground.com Blenderunderground]
|{{Englisch}}
| '''sehr gute''' Video-Tutorials
|}

== Sounds ==

===Musik===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.jamendo.com/ Jamendo.com]
|{{Englisch}}
|Viele Künstler stellen hier ihre Alben unter einer Creative Commons Lizenz online. Man kann dort die Künstler auch kontaktieren und fragen ob man ihre Musik nutzen kann. Taugt außerdem als Radio! ;)
|-
|[http://incompetech.com/m/c/royalty-free/ Incompetech.com]
|{{Englisch}}
|Viele sehr schön gemacht instrumentale Musik aus allen möglichen Genres. Sie ist frei verwenderbar, wenn man den Macher der Musik (Kevin MacLeod) in seinem Programm erwähnt. Aber das hat er auch verdient. Folgende Programme nutzen beispielsweise (auch) Musik von incompetech.com:
* OpenParty
|-
|}

===Soundeffekte===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.freesound.org/ freesound.org]
|{{Englisch}}
|Diverse Sounds unter [http://www.creativecommons.org/ CreativeCommons] Lizenzen.
|}

===Soundprogramme===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://audacity.sourceforge.net/?lang=de Sourceforgeseite von Audacity]
|{{Deutsch}}
|Ein einfaches, freies Programm um Sounddateien zu bearbeiten. Man kann es auch nutzen um Soundeffekte neu zu erstellen, indem man z.B. ein Geräusch mit dem Mikrofon aufnimmt und einige Effekt anwendet, um es passender und nicht mehr aufgenommen klingen zu lassen.
|-
|[http://lmms.sourceforge.net/ LMMS]
|{{Englisch}}
|LMMS (Linux MultiMedia Studio) ist ein OpenSource+Freeware Composer-Programm ähnlich zum bekannteren aber auch teuren CuBase(r). Trotz des Namens auch für Windows erhältlich.
|}

Link

2011-08-13T17:43:53Z

Lord horazont: Unvollständigen Upload reparieren (1/2)

Diese Linksammlung soll allgemeine Links zu unterschiedlichen Themen bieten, die mit der Multimediaentwicklung zu tun haben.
{{Hinweis|Vielleicht ist eine Zusammenführung mit [[Tool]] sinnvoll!}}
{{Hinweis|Vielleicht ist eine Aufteilung in Unterseiten sinnvoll (möglicherweise mit Kategorien)}}

= Entwicklung mit OpenGL =

== Hardwareinfos ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://delphi3d.net/hardware/listreports.php OpenGL Hardware Registry - Hardwareübersicht]
|{{Englisch}}
|Eine Datenbank aller Grafikkarten die in der Harware Registry vorhanden sind. Die einzelnen Artikel enthalten Infos darüber, welche Extensions von der Grafikkarte unterstützt werden.
|-
|[http://delphi3d.net/hardware/allexts.php OpenGL Hardware Registry - Extensionübersicht]
|{{Englisch}}
|Eine Datenbank aller Extensions die in der Harware Registry vorhanden sind. Die einzelnen Artikel enthalten Infos darüber, welche Grafikkarten die entsprechende Extension unterstützen.
|-
|}

== Tutorials ==

{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
||[[Tutorial|DGL Wiki - Tutorial]]
|{{Deutsch}}
|DelphiGL.com ist Betreiber dieses Wikis und stellt eine Vielzahl Tutorials mit Schwehrpunkt OpenGL zur Verfügung.
Neben Tutorials für Einsteiger und OpenGL Anfänger gibt es auch fortgeschrittene Themen wie Shader oder Partikelsysteme.Sprache der Wahl ist hier Delphi.
|-
|[http://www.joachimrohde.com/cms/xoops/modules/articles/index.php?cat_id=1 joachimrohde.com]
|{{Deutsch}}
|Auf dieser Seite findet ihr deutsche Übersetzungen der bekannten NeHe Tutorials. Sprache der Wahl ist hier C++.
|-
|[http://www.cg.tuwien.ac.at/studentwork/VRSem96/OpenGL/ Technische Universität Wien]
|{{Deutsch}}
|
|-
|[http://nehe.gamedev.net/ Nehe]
|{{Englisch}}
|Die berühmt berüchtigten NeHe Tutorials sind eine umfangreiche Sammlung an Tutorials zum Thema OpenGL. Von Anfängertutorials bis hin zu komplexen Effekten wird alles behandelt. Sprache der Wahl ist hier C++. (Eine Übersetzung der NeHe Tutorials findet ihr bei Joachim Rhode (siehe oben). )
|-
|[http://www.sulaco.co.za/tut.htm sulaco.co.za]
|{{Englisch}}
| OpenGL Beispiele in Delphi
|}

== OpenGL Funktionen ==

=== GL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GL|DGL Wiki - Kategorie GL]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten OpenGL Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL.tar.gz OpenGL.org - Orginal Spezifkationen]
|{{Englisch}}
|Die Orginalspezifikationen der OpenGL 1.0 und OpenGL 1.1 Befehle. (Diese HTML-Dokumente sind nicht Copy&Paste freundlich, da sie vermutlich automatisch aus vorhandenen Dateien (Postscript) erzeugt wurden.)
|-
|[http://developer.3dlabs.com/documents/glmanpage_index.htm 3dLabs]
|{{Englisch}}
|Die Orginalspezifikationen der OpenGL 1.0 und OpenGL 1.1 Befehle.
|-
|[http://www.mevis.de/~uwe/opengl/opengl.html mevis.de]
|{{Englisch}}
|Sammlung von Englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|[http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/glfunc01_4f03.asp MSDN von Microsoft]
|{{Englisch}}
|OpenGL Dokumentation in der MSDN. Die Erklärung der MSDN sind meist keine reinen Kopien der Orginalspezifikationen, sondern enthalten hin und wieder auch zusätzliche Informationen, oder formulieren Texte auf verständlichere Art und Weise.
|-
|}

=== GLU ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GLU|DGL Wiki - Kategorie GLU]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten GLU Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/glu/ OpenGL.org - Orginal Spezifkationen]
|{{Englisch}}
|Orginalspezifikationen für die GLU Befehle. (Diese HTML-Dokumente sind nicht Copy&Paste freundlich, da sie vermutlich automatisch aus vorhandenen Dateien (Postscript) erzeugt wurden.)
|-
|[http://www.mevis.de/~uwe/opengl/opengl.html mevis.de]
|{{Englisch}}
|Sammlung von englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|[http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/glufnc01_0e43.asp MSDN von Microsoft]
|{{Englisch}}
|GLU Dokumentation in der MSDN. Die Erklärung der MSDN sind meist keine reinen Kopien der Orginalspezifikationen, sondern enthalten hin und wieder auch zusätzliche Informationen, oder formulieren Texte auf verständlichere Art und Weise.
|-
|}

=== GLX ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GLX|DGL Wiki - Kategorie GLX]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten GLX Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/glx/ OpenGL.org - Orginal Spezifkationen]
|{{Englisch}}
|Orgninalspezifikationen der GLX Befehle bei OpenGL.org.
|-
|[http://www.mevis.de/~uwe/opengl/opengl.html mevis.de]
|{{Englisch}}
|Sammlung von Englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|}

=== WGL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:WGL|DGL Wiki - Kategorie WGL]]
|{{Deutsch}}
|Wiki-Kategorie die alle übersetzten WGL Befehle enthält.
|-
|[http://developer.3dlabs.com/documents/wglmanpage_index.htm 3dLabs]
|{{Englisch}}
|Sammlung einiger WGL Befehlsspezifikationen.
|-
|}

=== GLUT ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://freeglut.sourceforge.net/docs/api.php The freeglut Projekt]
|{{Englisch}}
|Englischsprachige Dokumentation zum OpenGL Utility Toolkit kurz GLUT.
|-
|}

=== SDL ===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:SDL|DGL Wiki - Kategorie SDL]]
|{{Deutsch}}
|Übersicht aller auf die SDL bezogenen Artikel hier im Wiki. Darunter befinden sich eine Vielzahl von Übersetzungen der SDL Befehlspezifikationen. Diese können auch in der [[SDL-Funktionsübersicht]] gefunden werden.
|-
|[http://www.libsdl.org/cgi/docwiki.cgi/SDL_20API libsdl.org]
|{{Englisch}}
|Das Dokumentationswiki von libSDL.org enthält die komplette Dokumenation zur SDL in englischer Sprache.
|-
|-
|[http://www.fp.sdl.de.vu/ fp.sdl.de.vu]
|{{Englisch}}
| Eine Webseite die speziell Informationen über die Programmierung von SDL unter Freepascal zur Verfügung stellt.
|-
|}

== FAQs ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[FAQ| DGL Wiki - FAQ]]
|{{Deutsch}}
|Ein FAQ (Frequently Asked Questions = Häufig gestellte Fragen) zu DelphiGL.com und dem DGL Wiki.
|-
|[http://www.3dsource.de/faq/index.htm 3dsource.de]
|{{Deutsch}}
|Ein FAQ zu Fragen rund um OpenGL.
|-
|}

== Effekte und Techniken mit OpenGL ==

===Glow===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamasutra.com/view/feature/2107/realtime_glow.php Gamasutra]
|{{Englisch}}
|Beschreibt, wie man mit Hilfe von Shader(hier DirectX Shader) den Gloweffekt in Realtime umsetzt. Dabei wird erst die Technik dahinter erklährt, und dann wie man sie Schritt für Schritt umsetzt.
|-
|[http://collective.valve-erc.com/index.php?go=tron1 valve-erc.com]
|{{Englisch}}
|Schritt für Schritt Anleitung, wie man mit Hilfe von Cg in OpenGL den Glow Effekt realisieren kann
|-
|}

===HDR===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamedev.net/columns/hardcore/hdrrendering/ gamedev.net]
|{{Englisch}}
|Hier wird sehr kurz eingeleitet, was HDR Rendering überhaupt ist, dann wird der Aufbau des *.hdr Formats erläutert, und dann geht es schon von 0 auf 100 zum Programmieren. Erklährungen gibt es kaum, dafür werden fertige Shader(für DirectX) geboten.
|-
|[http://www.gamedev.net/reference/articles/article2208.asp gamedev.net]
|{{Englisch}}
|Beschreibt auch nur etwas kurz das HDR Verfahren, jedoch mit mehr mathematischen Hintergrund in Sachen Tonemapping. Beispielcode für Tonemapping in C++ liegt bei.
|-
|}

===BSP Bäume===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.3dtechdev.com/tutorials/leafbsp/3dbsptrees.html 3dtechdev.com]
|{{Englisch}}
|Das beste Dokument überhaupt, für allem die selber BSP Bäume compilieren möchte. Ist belegt mit sehr viel Grafik. Erst beginnt er das Prinzip allgemein zum umschreiben, dann wird alles genau erläutert, und mit verständlichen Pseudocode untermalt.
|-
|[http://www.3dtechdev.com/tutorials/illegalgeometry/illegalgeometrytut.html 3dtechdev.com]
|{{Englisch}}
|Nicht ganz so gut geworden, wie sein erstes Tutorial, aber erklährt auch sehr gut, wie man illegale Geometrie aufspürt und beseitigt. Wieder mit Grafiken und Pseudocodes verständlich belegt. Hiermit kann man seinem Map-Compiler den letzten Schliff verleien.
|-
|[http://www.gamedev.net/reference/articles/article981.asp Gamedev]
|{{Englisch}}
|Von Michael Abrash, dürfte der ''Erfinder'' von Quake sein. Naja, meine Englischkenntnisse reichen hier nicht ganz aus, um den Text zu verstehen. Ist etwas umständlich geschrieben. Dafür mit Grafiken unterlegt.
|-
|[http://www.zfx-online.de/Tutorials.php?ID=11 Part 1 - Allgemein]
|{{Deutsch}}
|Einzigste deutsche Referenz zu BSP Bäumen, dafür Daumen hoch. Ist aber nicht das Wahre: schlechter C Code, und ich hatte auch nicht den Einduck, das er die Theorie zu diesem Thema bis in die Tiefe verstanden hat(oder er wollte es nicht zu akademisch Erklähren oO). Aber ein guter Einstieg in dieses Thema.
|-
|[http://www.zfx-online.de/Tutorials.php?ID=13 Part 2 - Kollision und PVS]
|{{Deutsch}}
|-
|[http://www.cs.uwec.edu/~stevende/cs455/programs/GameTutorials%20-%20Quake%203%20BSP%20Format.htm Quake3 *.bsp Format]
|{{Englisch}}
|Die beste Dokumentation für das BSP Format, die ich gefunden habe, besser als den Quake3 Sourcecode zu durchforsten. Leider etwas magere Eklährung zu wichtigen Themen wie Patches(Curved Surfaces). Ich pers. hatte jetzt 1 1/2 Wochen gebraucht, um das *.bsp Format vollständig zu verstehen. Ist aber anscheinend die beste Format Dokumentation im Netz.
|-
|[http://www.flipcode.com/articles/article_q2bsp.shtml Quake2 *.bsp Format]
|{{Englisch}}
|Kann auch nur soviel sagen, wie beim Link zuvor. Es fehlen hier auch zum Teil Informationen. Man muss halt viel ausprobieren, und sich den Quake 2 Source zu Herzen nehmen, damit man es versteht.
|-
|}

===Himmel & Wolken===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamedev.net/community/forums/topic.asp?topic_id=86024 Gamedev]
|{{Englisch}}
|Guter Thread mit vielen Anregungen und Links.
|-
|[http://www.gamedev.net/community/forums/topic.asp?topic_id=135654 Gamedev]
|{{Englisch}}
|Hier wird die Diskussion zum obigen Link weitergeführt.
|-
|[http://freespace.virgin.net/hugo.elias/models/m_clouds.htm Plasma]
|{{Englisch}}
|Eine nette Idee um Plasma in Echtzeit zu generieren, und zu verändern. Leider nichts zum Shading.
|-
|[http://nis-lab.is.s.u-tokyo.ac.jp/~nis/cdrom/sig00_cloud.pdf 3D Wolken]
|{{Englisch}}
|Paper über generieren und rendern von 3 dimensionalen Wolken inklusive Schatten und Lichtstrahlen. Ich hab nur den Lichtstahlen-Algorithmus ausprobiert. Saulangsam aber sehr einfach zu implementieren. Einen Blick ist es auf jeden Fall wert.
|-
|[http://www.geocities.com/ngdash/whitepapers/skydomecolor.html Skydome]
|{{Englisch}}
|Wenn man mal schnell gute Farben für seinen Skydome braucht...
|}

===Terrain===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.flipcode.com/articles/article_geomipmaps.shtml FlipCode]
|{{Englisch}}
|Artikel zu Geomipmaping. Zummindest hab ich es hier zum ersten mal gesehen. Und es funzt ganz gut.
|-
|[http://www.vterrain.org Virtual Terrain Project]
|{{Englisch}}
|Eine Seite mit Links und Artikeln zu allem, was etwas mit Terrainrendering zu tun hat.
|-
|}

===Sonstiges===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[Materialsammlung]]
|{{Deutsch}}
|Sammlung von gängigen Parametern für [[glMaterial]] hier im Wiki.
|-
|[http://freespace.virgin.net/hugo.elias/radiosity/radiosity.htm Radiosity]
|{{Englisch}}
|Erklährt sehr schön die Funktionsweise von Radiosity, liefert Beispielcodes und ist recht gut illustriert.
|-
|[http://legion.gibbering.net/projectx/paper/shadow%20mapping/ Shadowmapping]
|{{Englisch}}
|Beschreibt das Trapezoidal Shadow Mapping - Verfahren für gerichte Lichter.
|-
|[http://www.flipcode.com/articles/article_generatingnames.shtml Namensgenerator]
|{{Englisch}}
|Per Zufallsgenrator Namen erzeugen, und nie wieder kreativ werden müssen.
|-
|[http://www.paulsprojects.net/tutorials/simplebump/simplebump.html Bumpmapping]
|{{Englisch}}
|Bumpmapping auf Lowend-Grakas. Damals war Bumpmapping noch was ganz tolles...
|-
|[http://www.paulsprojects.net/opengl/dpreflect/dpreflect.html Dot Product Reflect]
|{{Englisch}}
|zwar nur ne Demo, aber wenn man schon immer mal mit EMBM das Wasser aus Morrowind nachproggen wollte...
|-
|}

== Beispiele/Demos mit Quelltext ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.delphigl.de DelphiGL.de]
|{{Deutsch}}
| Hier finden sich besonders eindrucksvolle Newton Physik Demos. Meißtens sogar mit Quelltext.
|-
|[http://www.shadow3d.de.vu/ Shadow 3D]
|{{Deutsch}}
| Hier finden sich zwei Demos wie man Quake 3 Modelle lädt und eine glSlang Demo
|-
|[[Shadersammlung]] im DGL Wiki
|{{Deutsch}}
| Hier findet man freie Shadersourcen.
|-
|[http://www.humus.name Humus]
|{{Englisch}}
| Diverse eindrucksvolle Demos zu verschiedenen Techniken, häufig mit Quelltext in C (teilweise OpenGL / DirectX)
|}

== weitere Links ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www-user.tu-chemnitz.de/~pester/Lehre/CompGeo.pdf CompGeo.pdf]
|{{Deutsch}}
| Script "Einführung in die Computergeometrie" von Dr. Pester (TU-Chemnitz). Ideales Nachschlagewerk für die Mathematik die einem bei der Grafikprogrammierung so begegnet.
|-
|[http://www.robsite.de/ robsite.de]
|{{Deutsch}}
| Auf dieser riesigen Seite finden sich auch viele weitere Links über verschiedene Themen der 3D Programmierung.
|-
|[http://www.3dlinks.com/links.cfm?categoryid=3&subcategoryid=21 3dlinks.com]
|{{Englisch}}
| Diese Seite hat es sich zur Hauptaufgabe gemacht Links auf Seiten mit dem Thema 3D zu sammeln.
|-
|[http://www.two-kings.de/links.html two-kings.de]
|{{Englisch}}
| Sammlung diverser interessanter Links, vorallem auf Themen im gamedev-Forum verweisend.
|-
|[http://www.delgine.com Delgine.com]
|{{Englisch}}
| Heimat des freien 3D Modellers "DeleD", welcher in Delphi programmiert ist. Ihr findet dort auch Modellpackete, Texturpackete, Plugins und Hilfe bei der Programmierung von Delphi und OpenGL.
|}

= Spieleentwicklung =

==Allgemein==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.spieleprogrammierung.net/ Spieleprogrammierung - OpenGL - GLSL - OpenAL - KI - Animation - Spielephysik]
|{{Deutsch}}
|Auf dieser Seite findet Ihr Artikel, Tutorials und Programmbeispiele rund um das Thema Spieleprogrammierung. Programmiersprache ist hier C/C++.
|-
|[http://graphics-and-physics-framework.spieleprogrammierung.net/ OpenGL Graphics And Physics Framework]
|{{Deutsch}}
|Auf dieser Seite findet Ihr ein frei verfügbares OpenGL basiertes Grafik und Physik Framework (LGPL-Lizenz) samt zugehöriger Probammbeispiele. Programmiersprache ist hier C/C++.
|-
|[http://audio-framework.spieleprogrammierung.net/ OpenAL Audio Framework]
|{{Deutsch}}
|Auf dieser Seite findet Ihr ein frei verfügbares OpenAL Audio Framework (LGPL-Lizenz) samt zugehöriger Probammbeispiele. Unterstützt werden 3D Sounds, EFX (EAX Alternative) Reverb Effekte sowie Audio Streaming (Music and Voices). Programmiersprache ist hier C/C++.
|-
|[http://spieleentwicklung-im-web.spieleprogrammierung.net/ Spieleentwicklung im Web]
|{{Deutsch}}
|Auf dieser Seite findet Ihr Links (E-Books, Präsentationen, wissenschaftliche Arbeiten und Tutorials) zu verschiedenen Themengebieten der Spieleentwicklung.
|-
|}

==Kopierschutz==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://inner-smile.com/nocrack.phtml Inner-Smile.com]
|{{Englisch}}
| Seite mit Gedanken zum Thema "Wie schütze ich meine Programme vor Crackern". Falls die Seite nicht erreichbar ist hat Google noch ne [http://www.google.com/search?q=cache:hpqPT5G4WB0J:www.inner-smile.com/nocrack.phtml+http://inner-smile.com/nocrack.phtml&hl=de&gl=de&ct=clnk&cd=1 Version im Archiv].
|-
|}

== Künstliche Intelligenz ==
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.kbs.uni-hannover.de/Lehre/KI2/Presentationen/presentation9798/esprit/spieltheorie/spieltheorie.html Uni-Hannover - Spieltheorie]
|{{Deutsch}}
|Artikel über die Grundlagen von KI in Spielen.
|-
|[http://www.robsite.de/tutorials.php?tut=ki Robsite KI-Tutorials]
|{{Deutsch}}
| Sammlung von Texten zum Thema KI in Spielen. Beispiele sind meist in C++.
|-
|[http://ai-depot.com/ AI-Depot.com]
|{{Englisch}}
| Seite die sich ausschließlich mit KI in Spielen beschäftigt.
|-
|[http://www.ai-junkie.com/links.html AI-Junkie.com]
|{{Englisch}}
|Linkseite mit vielen KI relevanten Links. Die Seite AI-Junie selbst behandelt auch viele Themen rund um KI.
|-
|[http://www.aiwisdom.com/ AIWisdom.com]
|{{Englisch}}
|Seite die sich mit KIs in Spielen beschäftigt und sich zum Ziel gesetzt hat, alle Artikel zum Thema zu finden und zu Katalogisieren. Es gibt hier auch Artikel über die KIs bestehender Spiele.
|-
|[http://www.aiguru.com/ AIGuru.com]
|{{Englisch}}
|Newsseite zum Thema KI, Künstliches Leben, Hiernforschung, Robotik, Nanotechnologie - Halt alles was Spass macht.
|-
|[http://www.generation5.org/ Generation5.org]
|{{Englisch}}
|Seite über KI, Robotik, etc. . Leider scheint die Seite Probleme zu haben regelmäßig aktualisiert zu werden. Aber zumindest sollte man einige Artikel finden. Die werden ja nicht schlecht.
|-
|www.gameai.com
|{{Englisch}}
|''Wurde Januar 2010 als down gemeldet. Weiss irgendwer etwas genaueres?'' Seite zum Thema KI in Spielen. Soll wohl einen gewissen Stellenwert in der AI-Szene haben.
|-
|[http://www-i1.informatik.rwth-aachen.de/~algorithmus/algo19.php Algorithmus der Woche - Informatikjahr 2006]
|{{Deutsch}}
|Vielleicht schon etwas älter aber doch eine gute Anleitung um eine einfache Schach-KI zu erstellen.
|}

= Ressourcen =
In dieser Gruppe finden sich Links um die Ressourcen für Eure Projekte zu erstellen.

Link

2011-08-13T17:42:37Z

Lord horazont: Umstrukturierung

Link

2011-03-04T15:24:20Z

Lord horazont: /* Soundprogramme */ LMMS

= Links die mit Grafik/OpenGL zu tun haben =
Hier finden Sie eine Übersicht von Links.

*Weitere Navigations Links findet Sie unter [[DGL Wiki:Portal]]
*Links zu Tools oder Programmen finden Sie unter [[Tool]]s

== Hardwareinfos ==
<div align="center">
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://delphi3d.net/hardware/listreports.php OpenGL Hardware Registry - Hardwareübersicht]
|{{Englisch}}
|Eine Datenbank aller Grafikkarten die in der Harware Registry vorhanden sind. Die einzelnen Artikel enthalten Infos darüber, welche Extensions von der Grafikkarte unterstützt werden.
|-
|[http://delphi3d.net/hardware/allexts.php OpenGL Hardware Registry - Extensionübersicht]
|{{Englisch}}
|Eine Datenbank aller Extensions die in der Harware Registry vorhanden sind. Die einzelnen Artikel enthalten Infos darüber, welche Grafikkarten die entsprechende Extension unterstützen.
|-
|}
</div>
<br><br>

== Tutorials ==

=== OpenGL ===
<div align="center">
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
||[[Tutorial|DGL Wiki - Tutorial]]
|{{Deutsch}}
|DelphiGL.com ist Betreiber dieses Wikis und stellt eine Vielzahl Tutorials mit Schwehrpunkt OpenGL zur Verfügung.
Neben Tutorials für Einsteiger und OpenGL Anfänger gibt es auch fortgeschrittene Themen wie Shader oder Partikelsysteme.Sprache der Wahl ist hier Delphi.
|-
|[http://www.joachimrohde.com/cms/xoops/modules/articles/index.php?cat_id=1 joachimrohde.com]
|{{Deutsch}}
|Auf dieser Seite findet ihr deutsche Übersetzungen der bekannten NeHe Tutorials. Sprache der Wahl ist hier C++.
|-
|[http://www.cg.tuwien.ac.at/studentwork/VRSem96/OpenGL/ Technische Universität Wien]
|{{Deutsch}}
|
|-
|[http://nehe.gamedev.net/ Nehe]
|{{Englisch}}
|Die berühmt berüchtigten NeHe Tutorials sind eine umfangreiche Sammlung an Tutorials zum Thema OpenGL. Von Anfängertutorials bis hin zu komplexen Effekten wird alles behandelt. Sprache der Wahl ist hier C++. (Eine Übersetzung der NeHe Tutorials findet ihr bei Joachim Rhode (siehe oben). )
|-
|[http://www.sulaco.co.za/tut.htm sulaco.co.za]
|{{Englisch}}
| OpenGL Beispiele in Delphi
|}
</div>
<br>

=== Textur Erstellung ===
<div align="center">
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://3d.diehlsworld.de/textures/index.htm 3d.diehlsworld.de]
|{{Deutsch}}
|Auf dieser Seite findet ihr kurze aber inhaltlich reiche Tutorials zu der Frage "Wie erstelle ich XXXXX-Texturen". Dabei reicht die Palette von Untergrundtexturen wie Gras, Sand , Fels und Wasser (und Kombinationen dieser) bis hin zu Blitzen und Partikeln. Als Programm wird hier Photoshop verwendet.
|-
|[http://www.gimps.de/gimp/textur-muster/ gimps.de]
|{{Deutsch}}
|Schritt für Schritt Anleitungen wie man mit Gimp verschiedene Texturen erstellt.
|-
|[http://cbt.k090999.de/gimp.php#texturen k090999.de]
|{{Deutsch}}
|Gimptutorials zum Erstellen verschiedene Texturen.
|}
</div>
<br>

=== Blender ===
<div align="center">
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://blendpolis.de/f/viewtopic.php?t=5786 Blendpolis]
|{{Deutsch}}
| Ein Thread im Forum von [http://blendpolis.de Blendpolis] in dem '''sehr''' viele Tutorials aufgelistet sind
|-
|[http://blendpolis.de/f/article_cat.php?fldAuto=7 Blendpolis]
|{{Deutsch}}
| Eigentliche Tutorial Seite von [http://blendpolis.de Blendpolis] die Auswahl ist hier aber nicht so groß
|-
|[http://wikivid.com/index.php/Blender Blender at wikivid.com]
|{{Englisch}}
| Linksammlung von Blender Video Tutorials
|-
|[http://www.blender.org/education-help/tutorials/getting-started/ blender3d.org]
|{{Englisch}}
| Auch die Heimatseite von Blender bietet viele Tutorials unter anderm auch Video Tuorials
|-
|[http://www.Blenderunderground.com Blenderunderground]
|{{Englisch}}
| '''sehr gute''' Video-Tutorials
|}
</div>
<br><br>

== OpenGL Funktionen ==

=== GL ===
<div align="center">
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GL|DGL Wiki - Kategorie GL]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten OpenGL Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL.tar.gz OpenGL.org - Orginal Spezifkationen]
|{{Englisch}}
|Die Orginalspezifikationen der OpenGL 1.0 und OpenGL 1.1 Befehle. (Diese HTML-Dokumente sind nicht Copy&Paste freundlich, da sie vermutlich automatisch aus vorhandenen Dateien (Postscript) erzeugt wurden.)
|-
|[http://developer.3dlabs.com/documents/glmanpage_index.htm 3dLabs]
|{{Englisch}}
|Die Orginalspezifikationen der OpenGL 1.0 und OpenGL 1.1 Befehle.
|-
|[http://www.mevis.de/~uwe/opengl/opengl.html mevis.de]
|{{Englisch}}
|Sammlung von Englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|[http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/glfunc01_4f03.asp MSDN von Microsoft]
|{{Englisch}}
|OpenGL Dokumentation in der MSDN. Die Erklärung der MSDN sind meist keine reinen Kopien der Orginalspezifikationen, sondern enthalten hin und wieder auch zusätzliche Informationen, oder formulieren Texte auf verständlichere Art und Weise.
|-
|}
</div>
<br>

=== GLU ===
<div align="center">
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GLU|DGL Wiki - Kategorie GLU]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten GLU Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/glu/ OpenGL.org - Orginal Spezifkationen]
|{{Englisch}}
|Orginalspezifikationen für die GLU Befehle. (Diese HTML-Dokumente sind nicht Copy&Paste freundlich, da sie vermutlich automatisch aus vorhandenen Dateien (Postscript) erzeugt wurden.)
|-
|[http://www.mevis.de/~uwe/opengl/opengl.html mevis.de]
|{{Englisch}}
|Sammlung von englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|[http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/glufnc01_0e43.asp MSDN von Microsoft]
|{{Englisch}}
|GLU Dokumentation in der MSDN. Die Erklärung der MSDN sind meist keine reinen Kopien der Orginalspezifikationen, sondern enthalten hin und wieder auch zusätzliche Informationen, oder formulieren Texte auf verständlichere Art und Weise.
|-
|}
</div>
<br>

=== GLX ===
<div align="center">
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:GLX|DGL Wiki - Kategorie GLX]]
|{{Deutsch}}
| Wiki-Kategorie die alle übersetzten GLX Befehle enthält.
|-
|[http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/glx/ OpenGL.org - Orginal Spezifkationen]
|{{Englisch}}
|Orgninalspezifikationen der GLX Befehle bei OpenGL.org.
|-
|[http://www.mevis.de/~uwe/opengl/opengl.html mevis.de]
|{{Englisch}}
|Sammlung von Englischsprachigen Spezifikationen für GL(bis Version 1.1), GLX und GLU Funktionen.
|-
|}
</div>
<br>

=== WGL ===
<div align="center">
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:WGL|DGL Wiki - Kategorie WGL]]
|{{Deutsch}}
|Wiki-Kategorie die alle übersetzten WGL Befehle enthält.
|-
|[http://developer.3dlabs.com/documents/wglmanpage_index.htm 3dLabs]
|{{Englisch}}
|Sammlung einiger WGL Befehlsspezifikationen.
|-
|}
</div>
<br>

=== GLUT ===
<div align="center">
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://freeglut.sourceforge.net/docs/api.php The freeglut Projekt]
|{{Englisch}}
|Englischsprachige Dokumentation zum OpenGL Utility Toolkit kurz GLUT.
|-
|}
</div>
<br>

=== SDL ===
<div align="center">
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[:Kategorie:SDL|DGL Wiki - Kategorie SDL]]
|{{Deutsch}}
|Übersicht aller auf die SDL bezogenen Artikel hier im Wiki. Darunter befinden sich eine Vielzahl von Übersetzungen der SDL Befehlspezifikationen. Diese können auch in der [[SDL-Funktionsübersicht]] gefunden werden.
|-
|[http://www.libsdl.org/cgi/docwiki.cgi/SDL_20API libsdl.org]
|{{Englisch}}
|Das Dokumentationswiki von libSDL.org enthält die komplette Dokumenation zur SDL in englischer Sprache.
|-
|-
|[http://www.fp.sdl.de.vu/ fp.sdl.de.vu]
|{{Englisch}}
| Eine Webseite die speziell Informationen über die Programmierung von SDL unter Freepascal zur Verfügung stellt.
|-
|}
</div>
<br><br>

== FAQs ==
<div align="center">
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[FAQ| DGL Wiki - FAQ]]
|{{Deutsch}}
|Ein FAQ (Frequently Asked Questions = Häufig gestellte Fragen) zu DelphiGL.com und dem DGL Wiki.
|-
|[http://www.3dsource.de/faq/index.htm 3dsource.de]
|{{Deutsch}}
|Ein FAQ zu Fragen rund um OpenGL.
|-
|}
</div>
<br><br>

== Effekte und Techniken mit OpenGL ==

===Glow===
<div align="center">
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamasutra.com/view/feature/2107/realtime_glow.php Gamasutra]
|{{Englisch}}
|Beschreibt, wie man mit Hilfe von Shader(hier DirectX Shader) den Gloweffekt in Realtime umsetzt. Dabei wird erst die Technik dahinter erklährt, und dann wie man sie Schritt für Schritt umsetzt.
|-
|[http://collective.valve-erc.com/index.php?go=tron1 valve-erc.com]
|{{Englisch}}
|Schritt für Schritt Anleitung, wie man mit Hilfe von Cg in OpenGL den Glow Effekt realisieren kann
|-
|}
</div>
<br>

===HDR===
<div align="center">
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamedev.net/columns/hardcore/hdrrendering/ gamedev.net]
|{{Englisch}}
|Hier wird sehr kurz eingeleitet, was HDR Rendering überhaupt ist, dann wird der Aufbau des *.hdr Formats erläutert, und dann geht es schon von 0 auf 100 zum Programmieren. Erklährungen gibt es kaum, dafür werden fertige Shader(für DirectX) geboten.
|-
|[http://www.gamedev.net/reference/articles/article2208.asp gamedev.net]
|{{Englisch}}
|Beschreibt auch nur etwas kurz das HDR Verfahren, jedoch mit mehr mathematischen Hintergrund in Sachen Tonemapping. Beispielcode für Tonemapping in C++ liegt bei.
|-
|}
</div>
<br>

===BSP Bäume===
<div align="center">
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.3dtechdev.com/tutorials/leafbsp/3dbsptrees.html 3dtechdev.com]
|{{Englisch}}
|Das beste Dokument überhaupt, für allem die selber BSP Bäume compilieren möchte. Ist belegt mit sehr viel Grafik. Erst beginnt er das Prinzip allgemein zum umschreiben, dann wird alles genau erläutert, und mit verständlichen Pseudocode untermalt.
|-
|[http://www.3dtechdev.com/tutorials/illegalgeometry/illegalgeometrytut.html 3dtechdev.com]
|{{Englisch}}
|Nicht ganz so gut geworden, wie sein erstes Tutorial, aber erklährt auch sehr gut, wie man illegale Geometrie aufspürt und beseitigt. Wieder mit Grafiken und Pseudocodes verständlich belegt. Hiermit kann man seinem Map-Compiler den letzten Schliff verleien.
|-
|[http://www.gamedev.net/reference/articles/article981.asp Gamedev]
|{{Englisch}}
|Von Michael Abrash, dürfte der ''Erfinder'' von Quake sein. Naja, meine Englischkenntnisse reichen hier nicht ganz aus, um den Text zu verstehen. Ist etwas umständlich geschrieben. Dafür mit Grafiken unterlegt.
|-
|[http://www.zfx-online.de/Tutorials.php?ID=11 Part 1 - Allgemein]
|{{Deutsch}}
|Einzigste deutsche Referenz zu BSP Bäumen, dafür Daumen hoch. Ist aber nicht das Wahre: schlechter C Code, und ich hatte auch nicht den Einduck, das er die Theorie zu diesem Thema bis in die Tiefe verstanden hat(oder er wollte es nicht zu akademisch Erklähren oO). Aber ein guter Einstieg in dieses Thema.
|-
|[http://www.zfx-online.de/Tutorials.php?ID=13 Part 2 - Kollision und PVS]
|{{Deutsch}}
|-
|[http://www.cs.uwec.edu/~stevende/cs455/programs/GameTutorials%20-%20Quake%203%20BSP%20Format.htm Quake3 *.bsp Format]
|{{Englisch}}
|Die beste Dokumentation für das BSP Format, die ich gefunden habe, besser als den Quake3 Sourcecode zu durchforsten. Leider etwas magere Eklährung zu wichtigen Themen wie Patches(Curved Surfaces). Ich pers. hatte jetzt 1 1/2 Wochen gebraucht, um das *.bsp Format vollständig zu verstehen. Ist aber anscheinend die beste Format Dokumentation im Netz.
|-
|[http://www.flipcode.com/articles/article_q2bsp.shtml Quake2 *.bsp Format]
|{{Englisch}}
|Kann auch nur soviel sagen, wie beim Link zuvor. Es fehlen hier auch zum Teil Informationen. Man muss halt viel ausprobieren, und sich den Quake 2 Source zu Herzen nehmen, damit man es versteht.
|-
|}
</div>
<br>

===Himmel & Wolken===
<div align="center">
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.gamedev.net/community/forums/topic.asp?topic_id=86024 Gamedev]
|{{Englisch}}
|Guter Thread mit vielen Anregungen und Links.
|-
|[http://www.gamedev.net/community/forums/topic.asp?topic_id=135654 Gamedev]
|{{Englisch}}
|Hier wird die Diskussion zum obigen Link weitergeführt.
|-
|[http://freespace.virgin.net/hugo.elias/models/m_clouds.htm Plasma]
|{{Englisch}}
|Eine nette Idee um Plasma in Echtzeit zu generieren, und zu verändern. Leider nichts zum Shading.
|-
|[http://nis-lab.is.s.u-tokyo.ac.jp/~nis/cdrom/sig00_cloud.pdf 3D Wolken]
|{{Englisch}}
|Paper über generieren und rendern von 3 dimensionalen Wolken inklusive Schatten und Lichtstrahlen. Ich hab nur den Lichtstahlen-Algorithmus ausprobiert. Saulangsam aber sehr einfach zu implementieren. Einen Blick ist es auf jeden Fall wert.
|-
|[http://www.geocities.com/ngdash/whitepapers/skydomecolor.html Skydome]
|{{Englisch}}
|Wenn man mal schnell gute Farben für seinen Skydome braucht...
|}
</div>
<br>

===Terrain===
<div align="center">
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.flipcode.com/articles/article_geomipmaps.shtml FlipCode]
|{{Englisch}}
|Artikel zu Geomipmaping. Zummindest hab ich es hier zum ersten mal gesehen. Und es funzt ganz gut.
|-
|[http://www.vterrain.org Virtual Terrain Project]
|{{Englisch}}
|Eine Seite mit Links und Artikeln zu allem, was etwas mit Terrainrendering zu tun hat.
|-
|}
</div>
<br>

===Sonstiges===
<div align="center">
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[[Materialsammlung]]
|{{Deutsch}}
|Sammlung von gängigen Parametern für [[glMaterial]] hier im Wiki.
|-
|[http://freespace.virgin.net/hugo.elias/radiosity/radiosity.htm Radiosity]
|{{Englisch}}
|Erklährt sehr schön die Funktionsweise von Radiosity, liefert Beispielcodes und ist recht gut illustriert.
|-
|[http://legion.gibbering.net/projectx/paper/shadow%20mapping/ Shadowmapping]
|{{Englisch}}
|Beschreibt das Trapezoidal Shadow Mapping - Verfahren für gerichte Lichter.
|-
|[http://www.flipcode.com/articles/article_generatingnames.shtml Namensgenerator]
|{{Englisch}}
|Per Zufallsgenrator Namen erzeugen, und nie wieder kreativ werden müssen.
|-
|[http://www.paulsprojects.net/tutorials/simplebump/simplebump.html Bumpmapping]
|{{Englisch}}
|Bumpmapping auf Lowend-Grakas. Damals war Bumpmapping noch was ganz tolles...
|-
|[http://www.paulsprojects.net/opengl/dpreflect/dpreflect.html Dot Product Reflect]
|{{Englisch}}
|zwar nur ne Demo, aber wenn man schon immer mal mit EMBM das Wasser aus Morrowind nachproggen wollte...
|-
|}
</div>
<br><br>

== Beispiele/Demos mit Quelltext ==
<div align="center">
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.delphigl.de DelphiGL.de]
|{{Deutsch}}
| Hier finden sich besonders eindrucksvolle Newton Physik Demos. Meißtens sogar mit Quelltext.
|-
|[http://www.shadow3d.de.vu/ Shadow 3D]
|{{Deutsch}}
| Hier finden sich zwei Demos wie man Quake 3 Modelle lädt und eine glSlang Demo
|-
|[[Shadersammlung]] im DGL Wiki
|{{Deutsch}}
| Hier findet man freie Shadersourcen.
|-
|[http://www.humus.name Humus]
|{{Englisch}}
| Diverse eindrucksvolle Demos zu verschiedenen Techniken, häufig mit Quelltext in C (teilweise OpenGL / DirectX)
|}
</div>
<br><br>

== weitere Links ==
<div align="center">
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www-user.tu-chemnitz.de/~pester/Lehre/CompGeo.pdf CompGeo.pdf]
|{{Deutsch}}
| Script "Einführung in die Computergeometrie" von Dr. Pester (TU-Chemnitz). Ideales Nachschlagewerk für die Mathematik die einem bei der Grafikprogrammierung so begegnet.
|-
|[http://www.robsite.de/ robsite.de]
|{{Deutsch}}
| Auf dieser riesigen Seite finden sich auch viele weitere Links über verschiedene Themen der 3D Programmierung.
|-
|[http://www.3dlinks.com/links.cfm?categoryid=3&subcategoryid=21 3dlinks.com]
|{{Englisch}}
| Diese Seite hat es sich zur Hauptaufgabe gemacht Links auf Seiten mit dem Thema 3D zu sammeln.
|-
|[http://www.two-kings.de/links.html two-kings.de]
|{{Englisch}}
| Sammlung diverser interessanter Links, vorallem auf Themen im gamedev-Forum verweisend.
|-
|[http://www.delgine.com Delgine.com]
|{{Englisch}}
| Heimat des freien 3D Modellers "DeleD", welcher in Delphi programmiert ist. Ihr findet dort auch Modellpackete, Texturpackete, Plugins und Hilfe bei der Programmierung von Delphi und OpenGL.
|}
</div>

=Links zum Thema Spieleprogrammierung=

==Allgemein==
<div align="center">
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.spieleprogrammierung.net/ Spieleprogrammierung - OpenGL - GLSL - OpenAL - KI - Animation - Spielephysik]
|{{Deutsch}}
|Auf dieser Seite findet Ihr Artikel, Tutorials und Programmbeispiele rund um das Thema Spieleprogrammierung. Programmiersprache ist hier C/C++.
|-
|[http://audio-framework.spieleprogrammierung.net/ OpenAL Audio Framework]
|{{Deutsch}}
|Auf dieser Seite findet Ihr ein frei verfügbares OpenAL Audio Framework (LGPL-Lizenz) samt zugehöriger Probammbeispiele. Unterstützt werden 3D Sounds, EFX (EAX Alternative) Reverb Effekte sowie Audio Streaming (Music and Voices). Programmiersprache ist hier C/C++.
|-
|[http://spieleentwicklung-im-web.spieleprogrammierung.net/ Spieleentwicklung im Web]
|{{Deutsch}}
|Auf dieser Seite findet Ihr Links (E-Books, Präsentationen, wissenschaftliche Arbeiten und Tutorials) zu verschiedenen Themengebieten der Spieleentwicklung.
|-
|}
</div>

==Kopierschutz==
<div align="center">
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://inner-smile.com/nocrack.phtml Inner-Smile.com]
|{{Englisch}}
| Seite mit Gedanken zum Thema "Wie schütze ich meine Programme vor Crackern". Falls die Seite nicht erreichbar ist hat Google noch ne [http://www.google.com/search?q=cache:hpqPT5G4WB0J:www.inner-smile.com/nocrack.phtml+http://inner-smile.com/nocrack.phtml&hl=de&gl=de&ct=clnk&cd=1 Version im Archiv].
|-
|}
</div>

==KI==
<div align="center">
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.kbs.uni-hannover.de/Lehre/KI2/Presentationen/presentation9798/esprit/spieltheorie/spieltheorie.html Uni-Hannover - Spieltheorie]
|{{Deutsch}}
|Artikel über die Grundlagen von KI in Spielen.
|-
|[http://www.robsite.de/tutorials.php?tut=ki Robsite KI-Tutorials]
|{{Deutsch}}
| Sammlung von Texten zum Thema KI in Spielen. Beispiele sind meist in C++.
|-
|[http://ai-depot.com/ AI-Depot.com]
|{{Englisch}}
| Seite die sich ausschließlich mit KI in Spielen beschäftigt.
|-
|[http://www.ai-junkie.com/links.html AI-Junkie.com]
|{{Englisch}}
|Linkseite mit vielen KI relevanten Links. Die Seite AI-Junie selbst behandelt auch viele Themen rund um KI.
|-
|[http://www.aiwisdom.com/ AIWisdom.com]
|{{Englisch}}
|Seite die sich mit KIs in Spielen beschäftigt und sich zum Ziel gesetzt hat, alle Artikel zum Thema zu finden und zu Katalogisieren. Es gibt hier auch Artikel über die KIs bestehender Spiele.
|-
|[http://www.aiguru.com/ AIGuru.com]
|{{Englisch}}
|Newsseite zum Thema KI, Künstliches Leben, Hiernforschung, Robotik, Nanotechnologie - Halt alles was Spass macht.
|-
|[http://www.generation5.org/ Generation5.org]
|{{Englisch}}
|Seite über KI, Robotik, etc. . Leider scheint die Seite Probleme zu haben regelmäßig aktualisiert zu werden. Aber zumindest sollte man einige Artikel finden. Die werden ja nicht schlecht.
|-
|www.gameai.com
|{{Englisch}}
|''Wurde Januar 2010 als down gemeldet. Weiss irgendwer etwas genaueres?'' Seite zum Thema KI in Spielen. Soll wohl einen gewissen Stellenwert in der AI-Szene haben.
|-
|[http://www-i1.informatik.rwth-aachen.de/~algorithmus/algo19.php Algorithmus der Woche - Informatikjahr 2006]
|{{Deutsch}}
|Vielleicht schon etwas älter aber doch eine gute Anleitung um eine einfache Schach-KI zu erstellen.
|}
</div>

=Links für nicht grafische Medien=

==Sound==

===Musik===
<div align="center">
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.jamendo.com/ Jamendo.com]
|{{Englisch}}
|Viele Künstler stellen hier ihre Alben unter einer Creative Commons Lizenz online.
|-
|[http://incompetech.com/m/c/royalty-free/ Incompetech.com]
|{{Englisch}}
|Viele sehr schön gemacht instrumentale Musik aus allen möglichen Genres. Sie ist frei verwenderbar, wenn man den Macher der Musik (Kevin MacLeod) in seinem Programm erwähnt. Aber das hat er auch verdient. Folgende Programme nutzen beispielsweise (auch) Musik von incompetech.com:
* OpenParty
|-
|}
</div>

===Soundeffekte===
<div align="center">
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://www.freesound.org/ freesound.org]
|{{Englisch}}
|Diverse Sounds unter [http://www.creativecommons.org/ CreativeCommons] Lizenzen.
|}
</div>

===Soundprogramme===
<div align="center">
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[http://audacity.sourceforge.net/?lang=de Sourceforgeseite von Audacity]
|{{Deutsch}}
|Ein einfaches, freies Programm um Sounddateien zu bearbeiten. Man kann es auch nutzen um Soundeffekte neu zu erstellen, indem man z.B. ein Geräusch mit dem Mikrofon aufnimmt und einige Effekt anwendet, um es passender und nicht mehr aufgenommen klingen zu lassen.
|-
|[http://lmms.sourceforge.net/ LMMS]
|{{Englisch}}
|LMMS (Linux MultiMedia Studio) ist ein OpenSource+Freeware Composer-Programm ähnlich zum bekannteren aber auch teuren CuBase(r). Trotz des Namens auch für Windows erhältlich.
|}
</div>

Link

2011-03-04T15:21:42Z

Lord horazont: /* Soundeffekte */ Freesound.org (Lizenzen? Lizensen? Schwieriges Wort)