DGL Wiki - Benutzerbeiträge [de]

Link

2021-08-30T16:39:10Z

Glawesome: /* Soundeffekte */ noch ein Typo

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 Schwerpunkt 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! ;)
|-
|[https://incompetech.com/music/ Incompetech.com]
|{{Englisch}}
|Viele sehr schön gemacht instrumentale Musik aus allen möglichen Genres. Sie ist frei verwendbar, 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
|-
|[https://freepd.com/ freepd.com]
|{{Englisch}}
|Musik ebenfalls von Kevin MacLeod und anderen Künstlern, die sogar unter Public Domain steht. Man darf sie also kostenlos für alles verwenden und muss noch nicht mal den Urheber nennen (wäre natürlich trotzdem nett).
|-
|}

===Soundeffekte===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[https://www.freesound.org/ freesound.org]
|{{Englisch}}
|Diverse Sounds unter [https://creativecommons.org/ CreativeCommons] Lizenzen.
|-
|[https://sonniss.com/gameaudiogdc SONNISS Game Audio GDC]
|{{Englisch}}
|Gigabyteweise hochqualitative Sounds, kostenlos und kommerziell nutzbar. Ist wohl als Werbung für noch mehr Sounds von SONNISS gedacht.
|}

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

2021-08-30T16:38:33Z

Glawesome: /* Soundeffekte */ typo

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 Schwerpunkt 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! ;)
|-
|[https://incompetech.com/music/ Incompetech.com]
|{{Englisch}}
|Viele sehr schön gemacht instrumentale Musik aus allen möglichen Genres. Sie ist frei verwendbar, 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
|-
|[https://freepd.com/ freepd.com]
|{{Englisch}}
|Musik ebenfalls von Kevin MacLeod und anderen Künstlern, die sogar unter Public Domain steht. Man darf sie also kostenlos für alles verwenden und muss noch nicht mal den Urheber nennen (wäre natürlich trotzdem nett).
|-
|}

===Soundeffekte===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[https://www.freesound.org/ freesound.org]
|{{Englisch}}
|Diverse Sounds unter [https://creativecommons.org/ CreativeCommons] Lizenzen.
|-
|[https://sonniss.com/gameaudiogdc SONNISS Game Audio GDC]
|{{Englisch}}
|Gigabyteweise hochqualitative Sounds, kostenlos und kommerziell nutzbar. Ist wohl als Werbung für noch mehr Sounds von SONISS gedacht.
|}

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

2021-08-28T11:57:43Z

Glawesome: /* Soundeffekte */ SONISS Game Audio GDC

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 Schwerpunkt 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! ;)
|-
|[https://incompetech.com/music/ Incompetech.com]
|{{Englisch}}
|Viele sehr schön gemacht instrumentale Musik aus allen möglichen Genres. Sie ist frei verwendbar, 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
|-
|[https://freepd.com/ freepd.com]
|{{Englisch}}
|Musik ebenfalls von Kevin MacLeod und anderen Künstlern, die sogar unter Public Domain steht. Man darf sie also kostenlos für alles verwenden und muss noch nicht mal den Urheber nennen (wäre natürlich trotzdem nett).
|-
|}

===Soundeffekte===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[https://www.freesound.org/ freesound.org]
|{{Englisch}}
|Diverse Sounds unter [https://creativecommons.org/ CreativeCommons] Lizenzen.
|-
|[https://sonniss.com/gameaudiogdc SONISS Game Audio GDC]
|{{Englisch}}
|Gigabyteweise hochqualitative Sounds, kostenlos und kommerziell nutzbar. Ist wohl als Werbung für noch mehr Sounds von SONISS gedacht.
|}

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

Triple-Buffering

2018-11-25T20:22:17Z

Glawesome: Weiterleitung nach Framerate#Triple-Buffering erstellt

#REDIRECT [[Framerate#Triple-Buffering]]

Triple Buffering

2018-11-25T20:21:56Z

Glawesome: Weiterleitung nach Framerate#Triple-Buffering erstellt

#REDIRECT [[Framerate#Triple-Buffering]]

DGL Treffen/2018/Organisation

2018-07-28T10:38:45Z

Glawesome: /* Wer kommt mit? */ glAwesome gestrichen

Es wurde einmal mehr vorgeschlagen sich im Sommer zu treffen. Ort ist diesmal irgendwo in Polen... ;-)

Thema
"Going East" ;-)

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

==Wo?==
'''Polen''' 
[https://www.e-domizil.de/ferienhaus/376211/ferienhaus-in-swiecianowo-malechowo-ostseekueste-westpommern-westpommern-polen/ Ferienwohnungen], 
;Addresse: Święcianowo 48A, 76-142 Święcianowo, Polen
;Koordinaten: [https://www.openstreetmap.org/?mlat=54.279437&mlon=16.583419&zoom=8 54.279437° N, 16.583419° O]

==Wann?==
*Anreise: Sa 11.08.2018
*Abreise: So 19.08.2018

==Was kostet das?==
Für die Übernachter ca. 20€ pro Nacht plus Nahrung.
Für Ausflüge, Museen etc ca. 10-20€
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
(8=max)
!Anreise
!Kommentar
|-
|Flash
|X
|
|8
|PKW ab Berlin?
|(Frase + 1 Platz im PKW frei.)
|-
|i0n0s
|X
|
|8
|PKW ab Gießen
|(1 Platz im PKW frei.)
|-
|Phobeus
|x
|
|8
|PKW ab Hamburg (ARG Nord)
|(0 Platz im PKW frei.)
|-
|Pixelschubser
|x
|
|8
| via ARG Nord
|
|-
|End
|x
|
|8
| via ARG Nord
|
|-
|Polarwolf
|x
|
|1
|PKW am 12.8
|(1 Platz ab Hamburg)
(Früh los Nachts zurück)
|-
|<s>glAwesome</s>
|
|
|<s>8</s>
|<s>Mitfahrt bei Flash</s>
|<s>Zustieg bei Flash in Szczecin Gumience (Stettin Scheune)</s>
|-
|Frase
|x
|
|8
|Nürnberg -> Berlin, dann via Flash
|Zustieg bei Flash im Berliner Norden
|-
|''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 Mini-LAN
*Videoabende
*Live Projektvorstellung
**Frase: Masterprojekt Bildkompression von DSLR-RAW-Files mit SPIHT (Wavelets)
**Frase: Verteilter Lock-Mechanismus ohne zentralen Koordinator, LamportLock (Verteilte Systeme)
*Umgebung erkunden

==Was gibts zu essen?==

In Polen kann man sehr gut und sehr günstig essen gehen, so günstig, dass selber abwaschen teurer ist (kalkulatorischer Stundenlohn des Geschirrspülers).
Sollte Irgendetwas ein auswärtiges Essenfassen und anschließendes Abwaschen lassen verhindern folgen ein paar Malzeiten die sich schnell und einfach zubereiten lassen.

Notmalzeiten
{|{{Prettytable_B1}}
!Koch
!Speise
!Benötigte Zutaten
!Kommentar
|-
|Pixelschubser
|Spaghetti mit Tomatensauce
|Spaghetti, Fleischwurst, Letscho, Paprika, Parmesan, Pfeffer, Salz, Tomaten, Zwiebeln, Zuchini, Zucker
|Die Zutaten gibt es vor Ort günstiger als in Deutschland
|-
|Polarwolf
(am 12.8)
|Käse Toasti, Nicht näher bekanntes totes Tier in Stücken und Käsekuchen mit Kompott
|Rezept, jop hab ich.
|Zutaten, bring ich mit.
|-
|Frase
|Vegetarisches Chilli
|Zutaten: TODO, aber u.A. geschredderter Blumen- oder Grünkohl, Mais, Paprikas, Chillis, Salz, Pfeffer, Knoblauch, Zwiebeln …
|
|-
|Frase
|Shakshuka
|Zutaten: Tomaten, Eier, Kreuzkümmel (AKA Cumin), Knoblauch, Zwiebeln, Olivenöl, Salz, Pfeffer, optional Paprika. Dazu ein Weißbrot, am besten Pita.
|Das Brot lässt sich auch ganz einfach selber backen. Man braucht nur Mehl, Salz, Olivenöl und irgend eine Hefe.
|-
|WER
|WAS
|REZEPT/ZUTATEN
|}

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

DGL Treffen/2018/Organisation

2018-07-06T22:05:02Z

Glawesome: /* Wer kommt mit? */ glAwesome in Liste aufgenommen, soweit bisher möglich

Es wurde einmal mehr vorgeschlagen sich im Sommer zu treffen. Ort ist diesmal irgendwo in Polen... ;-)

Thema
"Going East" ;-)

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

==Wo?==
'''Polen''' 
[https://www.e-domizil.de/ferienhaus/376211/ferienhaus-in-swiecianowo-malechowo-ostseekueste-westpommern-westpommern-polen/ Ferienwohnungen], 
;Addresse: Święcianowo 48A, 76-142 Święcianowo, Polen
;Koordinaten: [https://www.openstreetmap.org/?mlat=54.279437&mlon=16.583419&zoom=8 54.279437° N, 16.583419° O]

==Wann?==
*Anreise: Sa 11.08.2018
*Abreise: So 19.08.2018

==Was kostet das?==
Für die Übernachter ca. 20€ pro Nacht plus Nahrung.
Für Ausflüge, Museen etc ca. 10-20€
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
(8=max)
!Anreise
!Kommentar
|-
|Flash
|X
|
|8
|PKW ab Berlin?
|(2 Plätze im PKW frei.)
|-
|i0n0s
|X
|
|8
|PKW ab Gießen
|(1 Platz im PKW frei.)
|-
|Phobeus
|x
|
|8
|PKW ab Hamburg (ARG Nord)
|(0 Platz im PKW frei.)
|-
|Pixelschubser
|x
|
|8
| via ARG Nord
|
|-
|End
|x
|
|8
| via ARG Nord
|
|-
|Polarwolf
|x
|
|1
|PKW am 12.8
|(1 Platz ab Hamburg)
(Früh los Nachts zurück)
|-
|glAwesome
|
|
|8
|Mitfahrt bei Flash?
|Antwort von Flash steht noch aus.
|-
|''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 Mini-LAN
*Videoabende
*Live Projektvorstellung
*Umgebung erkunden

==Was gibts zu essen?==

In Polen kann man sehr gut und sehr günstig essen gehen, so günstig, dass selber abwaschen teurer ist (kalkulatorischer Stundenlohn des Geschirrspülers).
Sollte Irgendetwas ein auswärtiges Essenfassen und anschließendes Abwaschen lassen verhindern folgen ein paar Malzeiten die sich schnell und einfach zubereiten lassen.

Notmalzeiten
{|{{Prettytable_B1}}
!Koch
!Speise
!Benötigte Zutaten
!Kommentar
|-
|Pixelschubser
|Spaghetti mit Tomatensauce
|Spaghetti, Fleischwurst, Letscho, Paprika, Parmesan, Pfeffer, Salz, Tomaten, Zwiebeln, Zuchini, Zucker
|Die Zutaten gibt es vor Ort günstiger als in Deutschland
|-
|Polarwolf
(am 12.8)
|Käse Toasti, Nicht näher bekanntes totes Tier in Stücken und Käsekuchen mit Kompott
|Rezept, jop hab ich.
|Zutaten, bring ich mit.
|-
|WER
|WAS
|REZEPT/ZUTATEN
|}

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

DGL Treffen/2018/Organisation

2018-07-06T21:58:15Z

Glawesome: /* Wo? */ Koordinaten verlinkt

Es wurde einmal mehr vorgeschlagen sich im Sommer zu treffen. Ort ist diesmal irgendwo in Polen... ;-)

Thema
"Going East" ;-)

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

==Wo?==
'''Polen''' 
[https://www.e-domizil.de/ferienhaus/376211/ferienhaus-in-swiecianowo-malechowo-ostseekueste-westpommern-westpommern-polen/ Ferienwohnungen], 
;Addresse: Święcianowo 48A, 76-142 Święcianowo, Polen
;Koordinaten: [https://www.openstreetmap.org/?mlat=54.279437&mlon=16.583419&zoom=8 54.279437° N, 16.583419° O]

==Wann?==
*Anreise: Sa 11.08.2018
*Abreise: So 19.08.2018

==Was kostet das?==
Für die Übernachter ca. 20€ pro Nacht plus Nahrung.
Für Ausflüge, Museen etc ca. 10-20€
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
(8=max)
!Anreise
!Kommentar
|-
|Flash
|X
|
|8
|PKW ab Berlin?
|(2 Plätze im PKW frei.)
|-
|i0n0s
|X
|
|8
|PKW ab Gießen
|(1 Platz im PKW frei.)
|-
|Phobeus
|x
|
|8
|PKW ab Hamburg (ARG Nord)
|(0 Platz im PKW frei.)
|-
|Pixelschubser
|x
|
|8
| via ARG Nord
|
|-
|End
|x
|
|8
| via ARG Nord
|
|-
|Polarwolf
|x
|
|1
|PKW am 12.8
|(1 Platz ab Hamburg)
(Früh los Nachts zurück)
|-
|''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 Mini-LAN
*Videoabende
*Live Projektvorstellung
*Umgebung erkunden

==Was gibts zu essen?==

In Polen kann man sehr gut und sehr günstig essen gehen, so günstig, dass selber abwaschen teurer ist (kalkulatorischer Stundenlohn des Geschirrspülers).
Sollte Irgendetwas ein auswärtiges Essenfassen und anschließendes Abwaschen lassen verhindern folgen ein paar Malzeiten die sich schnell und einfach zubereiten lassen.

Notmalzeiten
{|{{Prettytable_B1}}
!Koch
!Speise
!Benötigte Zutaten
!Kommentar
|-
|Pixelschubser
|Spaghetti mit Tomatensauce
|Spaghetti, Fleischwurst, Letscho, Paprika, Parmesan, Pfeffer, Salz, Tomaten, Zwiebeln, Zuchini, Zucker
|Die Zutaten gibt es vor Ort günstiger als in Deutschland
|-
|Polarwolf
(am 12.8)
|Käse Toasti, Nicht näher bekanntes totes Tier in Stücken und Käsekuchen mit Kompott
|Rezept, jop hab ich.
|Zutaten, bring ich mit.
|-
|WER
|WAS
|REZEPT/ZUTATEN
|}

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

Link

2017-05-12T19:19:51Z

Glawesome: /* Soundeffekte */ http -> https

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! ;)
|-
|[https://incompetech.com/music/ Incompetech.com]
|{{Englisch}}
|Viele sehr schön gemacht instrumentale Musik aus allen möglichen Genres. Sie ist frei verwendbar, 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
|-
|[https://freepd.com/ freepd.com]
|{{Englisch}}
|Musik ebenfalls von Kevin MacLeod und anderen Künstlern, die sogar unter Public Domain steht. Man darf sie also kostenlos für alles verwenden und muss noch nicht mal den Urheber nennen (wäre natürlich trotzdem nett).
|-
|}

===Soundeffekte===
{| width = "100%" {{Prettytable_B1}}
!width="25%"|Link
!width="5%"|Sprache
!width="70%"|Beschreibung
|-
|[https://www.freesound.org/ freesound.org]
|{{Englisch}}
|Diverse Sounds unter [https://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

2017-05-07T18:31:08Z

Glawesome: /* Musik */ Incompetech-Link angepasst, freepd.com 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://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! ;)
|-
|[https://incompetech.com/music/ Incompetech.com]
|{{Englisch}}
|Viele sehr schön gemacht instrumentale Musik aus allen möglichen Genres. Sie ist frei verwendbar, 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
|-
|[https://freepd.com/ freepd.com]
|{{Englisch}}
|Musik ebenfalls von Kevin MacLeod und anderen Künstlern, die sogar unter Public Domain steht. Man darf sie also kostenlos für alles verwenden und muss noch nicht mal den Urheber nennen (wäre natürlich trotzdem nett).
|-
|}

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

Vertex Array Object

2016-04-08T09:39:49Z

Glawesome: /* IBO */ Aussage war nicht in jedem Fall korrekt, jetzt korrigiert

Willkommen zu meinem ersten Tutorial. Hier möchte ich euch erklären, was es mit Vertex Array Objects (VAOs) auf sich hat und wie man sie verwendet.

==Warum VAOs?==
Nun werdet ihr euch vermutlich fragen, warum ihr schon wieder ein neues "Object" (neben [[VBO]], [[IBO]], [[FBO]] usw.) kennenlernen sollt. Da gibt es im Wesentlichen zwei Gründe:
Erstens habt ihr keine Wahl, wenn ihr mit einem [[Tutorial_OpenGL3_Zeichenkontext|OpenGL-Kontext ab Version 3.0]] im forward-compatible Modus VBOs benutzen möchtet. Ohne VAOs geht es da nicht.
Zweitens, und das ist vermutlich der Grund für diesen Zwang in neueren OpenGL-Versionen: Es erspart euch beim Rendern einige API-Funktionsaufrufe (konkret: [[glBindBuffer]], [[glEnableVertexAttribArray]] und [[glDisableVertexAttribArray]]), was bekanntlich der [[Performance]] zuträglich ist.
 
==Was merkt sich ein VAO?==
In einem VAO wird gespeichert, welches Datenformat die Vertices haben, die ihr rendern möchtet. Also beispielsweise, dass ein Vertex aus 3 floats für die Position, 3 unsigned bytes für den Normalenvektor und 2 floats als Textur-Koordinaten besteht. Außerdem merkt sich das VAO, woher (aus welchem VBO) diese Daten genomen werden sollen. Wenn ihr einen Indexbuffer bindet, merkt sich das VAO auch dies.

Kurz: Das VAO merkt sich alles, was ihr mit [[glVertexAttribPointer]] einstellen könnt plus den GL_ELEMENT_ARRAY_BUFFER, falls ihr einen gebunden habt.

Es ist wichtig, den Unterschied zwischen VBO und VAO zu verstehen. Man könnte sagen, das VBO enthält die eigentlichen Vertexdaten und das VAO enthält die Informationen, in welchem VBO sich die benötigten Daten befinden und in welchem Format sie vorliegen. Das VAO ist also eine Lesevorschrift für die Daten im VBO.

Ebenfalls wichtig: Obwohl im VAO gespeichert wird, aus welchem VBO die Daten beim Rendern entnommen werden sollen, führt das Binden des VAOs '''nicht''' dazu, dass das zugehörige VBO auch gebunden wird. Das ist auch nicht notwendig, denn welches VBO während des Zeichnens gebunden ist, hat keinen Einfluss auf den Rendervorgang. Entscheidend ist nur, welches VBO gebunden war, als das VAO initialisiert wurde (genauer: als ''glVertexAttribPointer'' aufgerufen wurde). Zum genauen Ablauf kommen wir im nächsten Abschnitt.
 
==Anwendung==
===Initialisierung===
====VBO====
Es empfiehlt sich, zuerst das VBO zu initialisieren. Da möchte ich an dieser Stelle nicht zu sehr in die Details gehen, denn dazu gibt es bereits ein eigenes [[Tutorial_Vertexbufferobject|Tutorial]]. Daher nur ein kurzes Stück Beispielcode:
<cpp>GLuint VboID; // für Delphi-Programmierer: var VboID : GLuint;
glGenBuffers(1, &VboID); // in Pascal: glGenBuffers(1, @VboID);
glBindBuffer(GL_ARRAY_BUFFER, VboID);
glBufferData(GL_ARRAY_BUFFER, vbo_size, data, usage);</cpp>

====VAO====
Wie fast alles in OpenGL, haben auch Vertex Array Objects einen Namen, der auch hier eigentlich nur ein Integer ist. Um einen solchen Namen zu erhalten, rufen wir die Funktion [[glGenVertexArrays]] auf:
<cpp>GLuint VaoID;
glGenVertexArrays(1, &VaoID);</cpp>
Anschließend wird das VAO das erste Mal gebunden:
<cpp>glBindVertexArray(VaoID);</cpp>
Spätestens hier sollte das VBO [[glBindBuffer|gebunden]] werden, falls noch nicht geschehen. Nun werden die Funktionen [[glEnableVertexAttribArray]] und [[glVertexAttribPointer]] aufgerufen, um das Vertexformat festzulegen. Zum Beispiel:
<cpp>glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(TVertex), 0); // 3 floats für Position
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(TVertex), 12); // 3 floats für den Normalenvektor
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(TVertex), 24); // 2 floats als Textur-Koordinaten</cpp>
Der erste Parameter der beiden Funktionen ist der Index des jeweils betroffenen Vertexshader-Attributs (eine Variable, die im Vertexshader mit ''attribute'' oder ''in'' deklariert wurde). Dieser muss entweder vor dem Linken des Shaders mit [[glBindAttribLocation]] festgelegt werden, oder er wird nach dem Linken mit [[glGetAttribLocation]] abgefragt.

====IBO====
An dieser Stelle besteht nun optional die Möglichkeit, auch einen Indexpuffer anzulegen. Dazu wieder ein kleines Stück Code:
<cpp>GLuint IboID;
glGenBuffers(1, &IboID);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IboID);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, ibo_size, indexdata, usage);</cpp>
Wichtig ist hierbei, dass ''glBindBuffer'' mit GL_ELEMENT_ARRAY_BUFFER nach ''glBindVertexArray'' aufgerufen werden muss. Sonst merkt sich das zuvor gebundene VAO den Indexbuffer (falls vorher ein anderes VAO gebunden war).

===VAO vor Veränderung "schützen"===
Nun haben wir das VAO vollständig gefüllt. Jetzt können wir, falls wir das möchten, ein anderes VAO binden, oder wir entbinden das aktuelle einfach mit
<cpp>glBindVertexArray(0);</cpp>
Damit sichern wir, dass sich nachfolgende Aufrufe von ''glVertexAttribPointer'' oder ''glBindBuffer'' nicht auf unser VAO auswirken.

===Rendern===
Jetzt kommt der schöne Part. Da das komplette Vertexformat nämlich schon im VAO gespeichert ist, reicht ein einziger Aufruf von
<cpp>glBindVertexArray(VaoID);</cpp>
und schon stellt OpenGL alles so ein, wie wir es bei der Initialisierung festgelegt haben. Es ist jetzt nicht einmal mehr notwendig, ein VBO zu binden. Wir können einfach drauflos zeichnen:
<cpp>glDrawArrays(GL_TRIANGLES, 0, vertices_count);</cpp>
Wer nicht nur ein VBO, sondern auch einen Indexbuffer angelegt hat, der schreibt statt der letzten Zeile nun:
<cpp>glDrawElements(GL_TRIANGLES, indices_count, GL_UNSIGNED_SHORT, 0);</cpp>

===Aufräumen===
Wenn wir das VAO nicht mehr benötigen, sollten wir es der Sauberkeit halber freigeben:
<cpp>glDeleteVertexArrays(1, &VaoID);</cpp>
[[glDeleteVertexArrays]] ist sozusagen das genaue Gegenstück zu ''glGenVertexArrays''.

==Schlusswort==
Das war schon alles! War doch gar nicht so schwer, oder? Falls dennoch Fragen offen geblieben sind, oder ihr etwas nicht versteht, dürft, nein sollt, ihr im [http://www.delphigl.com/forum/index.php Forum] gerne eure Fragen stellen. Ebenfalls freuen würde ich mich über Feedback zu diesem Tutorial oder zum Wiki allgemein. Dazu einfach einen Beitrag ins Unterforum [http://www.delphigl.com/forum/viewforum.php?f=8 "Feedback"] schreiben. In diesem Sinne: Vielen Dank fürs Lesen und Füße zurück! :)

==Siehe auch==
[[Tutorial Vertexbufferobject]] 
[[VBO ohne glInterleavedArrays]]

==Links==
http://www.opengl.org/wiki/Vertex_Specification#Vertex_Array_Object 
[http://www.opengl.org/registry/specs/ARB/vertex_array_object.txt ARB_vertex_array_object] (Extension, um VAOs bereits in OpenGL 2.1 zu nutzen)

Vertex Array Object

2016-04-08T08:59:14Z

Glawesome: Klargestellt, dass sich ein VAO auch den ELEMENT_ARRAY_BUFFER merkt

Willkommen zu meinem ersten Tutorial. Hier möchte ich euch erklären, was es mit Vertex Array Objects (VAOs) auf sich hat und wie man sie verwendet.

==Warum VAOs?==
Nun werdet ihr euch vermutlich fragen, warum ihr schon wieder ein neues "Object" (neben [[VBO]], [[IBO]], [[FBO]] usw.) kennenlernen sollt. Da gibt es im Wesentlichen zwei Gründe:
Erstens habt ihr keine Wahl, wenn ihr mit einem [[Tutorial_OpenGL3_Zeichenkontext|OpenGL-Kontext ab Version 3.0]] im forward-compatible Modus VBOs benutzen möchtet. Ohne VAOs geht es da nicht.
Zweitens, und das ist vermutlich der Grund für diesen Zwang in neueren OpenGL-Versionen: Es erspart euch beim Rendern einige API-Funktionsaufrufe (konkret: [[glBindBuffer]], [[glEnableVertexAttribArray]] und [[glDisableVertexAttribArray]]), was bekanntlich der [[Performance]] zuträglich ist.
 
==Was merkt sich ein VAO?==
In einem VAO wird gespeichert, welches Datenformat die Vertices haben, die ihr rendern möchtet. Also beispielsweise, dass ein Vertex aus 3 floats für die Position, 3 unsigned bytes für den Normalenvektor und 2 floats als Textur-Koordinaten besteht. Außerdem merkt sich das VAO, woher (aus welchem VBO) diese Daten genomen werden sollen. Wenn ihr einen Indexbuffer bindet, merkt sich das VAO auch dies.

Kurz: Das VAO merkt sich alles, was ihr mit [[glVertexAttribPointer]] einstellen könnt plus den GL_ELEMENT_ARRAY_BUFFER, falls ihr einen gebunden habt.

Es ist wichtig, den Unterschied zwischen VBO und VAO zu verstehen. Man könnte sagen, das VBO enthält die eigentlichen Vertexdaten und das VAO enthält die Informationen, in welchem VBO sich die benötigten Daten befinden und in welchem Format sie vorliegen. Das VAO ist also eine Lesevorschrift für die Daten im VBO.

Ebenfalls wichtig: Obwohl im VAO gespeichert wird, aus welchem VBO die Daten beim Rendern entnommen werden sollen, führt das Binden des VAOs '''nicht''' dazu, dass das zugehörige VBO auch gebunden wird. Das ist auch nicht notwendig, denn welches VBO während des Zeichnens gebunden ist, hat keinen Einfluss auf den Rendervorgang. Entscheidend ist nur, welches VBO gebunden war, als das VAO initialisiert wurde (genauer: als ''glVertexAttribPointer'' aufgerufen wurde). Zum genauen Ablauf kommen wir im nächsten Abschnitt.
 
==Anwendung==
===Initialisierung===
====VBO====
Es empfiehlt sich, zuerst das VBO zu initialisieren. Da möchte ich an dieser Stelle nicht zu sehr in die Details gehen, denn dazu gibt es bereits ein eigenes [[Tutorial_Vertexbufferobject|Tutorial]]. Daher nur ein kurzes Stück Beispielcode:
<cpp>GLuint VboID; // für Delphi-Programmierer: var VboID : GLuint;
glGenBuffers(1, &VboID); // in Pascal: glGenBuffers(1, @VboID);
glBindBuffer(GL_ARRAY_BUFFER, VboID);
glBufferData(GL_ARRAY_BUFFER, vbo_size, data, usage);</cpp>

====VAO====
Wie fast alles in OpenGL, haben auch Vertex Array Objects einen Namen, der auch hier eigentlich nur ein Integer ist. Um einen solchen Namen zu erhalten, rufen wir die Funktion [[glGenVertexArrays]] auf:
<cpp>GLuint VaoID;
glGenVertexArrays(1, &VaoID);</cpp>
Anschließend wird das VAO das erste Mal gebunden:
<cpp>glBindVertexArray(VaoID);</cpp>
Spätestens hier sollte das VBO [[glBindBuffer|gebunden]] werden, falls noch nicht geschehen. Nun werden die Funktionen [[glEnableVertexAttribArray]] und [[glVertexAttribPointer]] aufgerufen, um das Vertexformat festzulegen. Zum Beispiel:
<cpp>glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(TVertex), 0); // 3 floats für Position
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(TVertex), 12); // 3 floats für den Normalenvektor
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(TVertex), 24); // 2 floats als Textur-Koordinaten</cpp>
Der erste Parameter der beiden Funktionen ist der Index des jeweils betroffenen Vertexshader-Attributs (eine Variable, die im Vertexshader mit ''attribute'' oder ''in'' deklariert wurde). Dieser muss entweder vor dem Linken des Shaders mit [[glBindAttribLocation]] festgelegt werden, oder er wird nach dem Linken mit [[glGetAttribLocation]] abgefragt.

====IBO====
An dieser Stelle besteht nun optional die Möglichkeit, auch einen Indexpuffer anzulegen. Dazu wieder ein kleines Stück Code:
<cpp>GLuint IboID;
glGenBuffers(1, &IboID);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IboID);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, ibo_size, indexdata, usage);</cpp>
Man kann den Indexbuffer auch ganz am Anfang (vor dem VBO) anlegen. Jedoch muss ''glBindBuffer'' nach ''glBindVertexArray'' aufgerufen werden, damit sich das VAO den Indexbuffer merkt.

===VAO vor Veränderung "schützen"===
Nun haben wir das VAO vollständig gefüllt. Jetzt können wir, falls wir das möchten, ein anderes VAO binden, oder wir entbinden das aktuelle einfach mit
<cpp>glBindVertexArray(0);</cpp>
Damit sichern wir, dass sich nachfolgende Aufrufe von ''glVertexAttribPointer'' oder ''glBindBuffer'' nicht auf unser VAO auswirken.

===Rendern===
Jetzt kommt der schöne Part. Da das komplette Vertexformat nämlich schon im VAO gespeichert ist, reicht ein einziger Aufruf von
<cpp>glBindVertexArray(VaoID);</cpp>
und schon stellt OpenGL alles so ein, wie wir es bei der Initialisierung festgelegt haben. Es ist jetzt nicht einmal mehr notwendig, ein VBO zu binden. Wir können einfach drauflos zeichnen:
<cpp>glDrawArrays(GL_TRIANGLES, 0, vertices_count);</cpp>
Wer nicht nur ein VBO, sondern auch einen Indexbuffer angelegt hat, der schreibt statt der letzten Zeile nun:
<cpp>glDrawElements(GL_TRIANGLES, indices_count, GL_UNSIGNED_SHORT, 0);</cpp>

===Aufräumen===
Wenn wir das VAO nicht mehr benötigen, sollten wir es der Sauberkeit halber freigeben:
<cpp>glDeleteVertexArrays(1, &VaoID);</cpp>
[[glDeleteVertexArrays]] ist sozusagen das genaue Gegenstück zu ''glGenVertexArrays''.

==Schlusswort==
Das war schon alles! War doch gar nicht so schwer, oder? Falls dennoch Fragen offen geblieben sind, oder ihr etwas nicht versteht, dürft, nein sollt, ihr im [http://www.delphigl.com/forum/index.php Forum] gerne eure Fragen stellen. Ebenfalls freuen würde ich mich über Feedback zu diesem Tutorial oder zum Wiki allgemein. Dazu einfach einen Beitrag ins Unterforum [http://www.delphigl.com/forum/viewforum.php?f=8 "Feedback"] schreiben. In diesem Sinne: Vielen Dank fürs Lesen und Füße zurück! :)

==Siehe auch==
[[Tutorial Vertexbufferobject]] 
[[VBO ohne glInterleavedArrays]]

==Links==
http://www.opengl.org/wiki/Vertex_Specification#Vertex_Array_Object 
[http://www.opengl.org/registry/specs/ARB/vertex_array_object.txt ARB_vertex_array_object] (Extension, um VAOs bereits in OpenGL 2.1 zu nutzen)

Adaptive-Sync

2014-05-24T15:25:55Z

Glawesome: Weiterleitung nach Framerate#variable Bildschirmfrequenz erstellt

#REDIRECT: [[Framerate#variable_Bildschirmfrequenz]]

Framerate

2014-05-24T15:17:58Z

Glawesome: /* Adaptive Sync */

Das englische Wort "frame" lässt sich in etwa mit "Rahmen" übersetzen. Das "Frame" in Framerate hat aber nichts mit einem Bilderrahmen o.ä. zu tun, sondern gemeint ist der zeitliche Rahmen, in dem ein bestimmter Rechenvorgang stattfindet. Wenn man von der Framerate von Spielen spricht, ist ein Frame also genau die Zeit, die der Computer benötigt, um ein neues Bild auf den Bildschirm zu rendern. Die Framerate (auch '''Bildwiederholrate''') gibt an, wie viele dieser Frames pro Sekunde (fps) vergehen.

==24 fps Mythos==
Damit die grafische Ausgabe nicht wie eine Abfolge von Einzelbildern, sondern wie eine flüssige Bewegung aussieht, muss das angezeigte Bild schnell genug aktualisiert werden - mit anderen Worten: Die Framerate muss hoch genug sein. Experimente haben ergeben, dass das menschliche Auge eine Animation ab etwa 24 Bildern pro Sekunde nicht mehr als Bildfolge, sondern als Bewegung wahrnimmt. Daher stammt auch die weit verbreitete Meinung, ein Spieler könne keinen Unterschied zwischen 24 fps und beispielsweise 60 fps erkennen. Diese Annahme ist jedoch aus verschiedenen Gründen falsch! Siehe folgender Text.

==Unschärfe bei Bewegung==
Überlegen wir einmal, was passiert, wenn ein weißer Ball schnell von links nach rechts durchs Bild fliegt. Das erste Bild, das der Computer rendert, zeigt den Ball auf der linken Seite des Bildes. [[Datei:Ball_links.png|400px]] 
Sofort nachdem das Bild fertig ist, misst das Programm natürlich die Zeit, die es für das eine Bild gebraucht hat (bei 24 fps knapp 42 ms). Anhand der gemessenen Zeit kann es bestimmen, welche Strecke der Ball in dieser Zeit zurückgelegt hat (s = v*t, [[Timebased Movement]]). Nun verschiebt es den Ball um die entsprechende Strecke und beginnt sofort, das nächste Bild zu rendern. Nun ist der Ball schon in der Mitte des Bildschirms angelangt. [[Datei:Ball_mittig.png|400px]] 
Wieder misst das Programm die vergangene Zeit, verschiebt den Ball um die entsprechende Strecke und rendert das nächste Bild. Nun ist der Ball rechts. [[Datei:Ball_rechts.png|400px]] 
Im nächsten Bild wird er gar nicht mehr zu sehen sein. Der Betrachter bekommt also hintereinander drei gestochen scharfe Bilder zu sehen, die er als Bewegung interpretieren soll. Das Problem dabei ist das "gestochen scharf". 
Betrachten wir zum Vergleich einmal, was passieren würde, wenn sich diese Szene in der Natur abspielt. Der Ball wird von einer oder mehrerer Lichtquellen beleuchtet und reflektiert einen Teil des Lichts zum Auge des Betrachters. (Der Einfachheit halber nehmen wir an, dass der arme Betrachter nur ein Auge hat.) Währenddessen bewegt sich der Ball, und da der Betrachter seine Blickrichtung in dieser Zeit nicht ändert, wird das Licht während des Frames von 42 ms an verschiedene Stellen der Netzhaut reflektiert - allerdings wird kein Teil der Netzhaut 42 ms lang belichtet. Über den Sehnerv wird für jeden "Pixel" auf der Netzhaut der mittlere Helligkeitswert ans Gehirn übermittelt. Das Resultat ist ein grauer (nicht weißer) Streifen quer durchs Bild. Der Ball "verwischt" sozusagen, wie man es auch von Fotos mit zu langer Belichtungszeit kennt. [[Datei:Ball_verwischt.png|400px]] 
Genau diese Unschärfe erwartet auch der Spieler eines Computerspiels. Fehlt dieser Effekt, wirkt die Bewegung ruckelig. Eine Möglichkeit, diesen Effekt zu erzielen, wäre alle Bewegungen unscharf zu zeichnen. Das hat aber einen gewaltigen Nachteil, wie du im nächsten Abschnitt sehen wirst. Die andere Möglichkeit ist, einfach deutlich mehr Bilder pro Sekunde zu rendern, als nur 24.

==Schärfe bei Bewegung==
Warum ist das Unscharf-Zeichnen ([[Motion-Blur]]) keine Lösung des Problems? Ganz einfach: Man stelle sich die selbe Szene noch einmal vor - mit dem einzigen Unterschied, dass der Betrachter dieses Mal nicht auf eine Stelle starrt, sondern den Ball mit seinem Blick verfolgt. Er sieht also erst auf die linke Seite des Bildschirms und bewegt seinen Blick mit konstanter Geschwindigkeit nacht rechts. Was würde er erwarten zu sehen? Denk' mal kurz darüber nach. 
Der Spieler erwartet natürlich die selben Effekte, die er (unbewusst) zuvor in der Natur beobachtet hat. Nämlich dass der fliegende Ball gestochen scharf zu sehen ist, während der Hintergrund in Unschärfe verwischt. Denn dadurch, dass der Beobachter sein Auge immer nach dem Ball ausrichtet, trifft das von ihm reflektierte Licht immer die gleichen Stellen der Netzhaut. 
Dem Ball auf dem Bildschirm zu folgen, nachdem dieser unscharf gezeichnet wurde, geht aber nicht - man sieht ja nur einen grauen Streifen, überall dort, wo der Ball im Laufe des Frames einmal war. Das Problem ist, dass der Programmierer nicht wissen kann, wie der oder die Betrachter des Bildschirms ihre Augen bewegen.
Würde man die gesamte Szene ohne Motion-Blur aber mit 24000 fps rendern (was natürlich kein PC oder Bildschirm schaffen würde), dann würde sich der Ball in jedem Frame um einen oder zwei Pixel verschieben und wäre zu jeder Zeit gestochen scharf, wenn man ihm folgt. Gleichzeitig würde er (für das Auge) verwischen, wenn man ihm nicht folgt. 
Die einzige Möglichkeit, dem Spieler ein wirklich realistisches visuelles Erlebnis zu bieten, besteht also darin, eine möglichst hohe Framerate zu erzielen. Eine geringe Framerate lässt sich im Allgemeinen nicht mit Motion-Blur kompensieren. Der Blur-Effekt kostet sogar noch Leistung und sorgt damit für eine geringere Framerate (das gilt natürlich nicht in Filmen). Dennoch hat Motion-Blur seine Existenzberechtigung: Erstens wenn die FPS-Grenze des Monitors bereits erreicht ist. Und zweitens um Dinge mit übertriebenem Motion-Blur schneller aussehen zu lassen, als sie sind.

==Variation der Framerate==
Auch wenn die Framerate deutlich über 24 fps liegt, können selbst langsamere Bewegungen noch ruckelig wirken. Grund dafür ist dann, dass die Framelänge stark variiert. Als Beispiel muss mal wieder der Ball herhalten, der diesmal aber nicht in einer achtel Sekunde durchs gesamte Bild fliegt, sondern gemächlich mit konstanter Geschwindigkeit ins Bild rollt. Die Szene wird mit (normalerweise sehr flüssigen) 60 fps gerendert. Ein Frame hat also eine Dauer von 16,67 ms. Leider kommt es nun durch ungünstige Umstände dazu, dass ein einziges Frame plötzlich doppelt so lange dauert wie die anderen zuvor. Welche Auswirkungen hat also folgende Frame-Abfolge? 
{| border="1" rules="all"
! Frame
! Länge
|-
| Frame0
| 16,67
|-
| Frame1
| 16,67
|-
| Frame2
| 33,33
|-
| Frame3
| 16,67
|-
| Frame4
| 16,67
|} 
Die Hälfte von 60 fps sind 30 fps. Man sollte meinen, dass dies immer noch als ruckelfrei empfunden wird. Das Problem ist auch nicht die Framelänge als solches, sondern die Länge von Frame2 im Vergleich zu den anderen Frames. Der Betrachter erwartet, dass der Ball mit konstanter Geschwindigkeit weiterrollt. Während das Bild gezeichnet wird, kann das Programm noch nicht wissen, wie viel Zeit vergangen sein wird, wenn das Bild fertig ist. Deshalb wird der Ball ja immer um die Strecke verschoben, die der letzten Framelänge entspricht. In Frame2 wird also der Ball verschoben, als wenn der Zeichenvorgang nur 16,67 ms dauern würde. In Wirklichkeit vergeht aber doppelt so viel Zeit, so dass es dem Spieler vorkommt, als hätte der Ball seine Geschwindigkeit plötzlich halbiert. Aber es kommt noch schlimmer: Da Frame3 wieder nur 16,67 ms dauert, der Ball aber so weit fortbewegt wird, als würde der Frame 33,33 ms dauern, vervierfacht sich die Geschwindigkeit nun! Erst in Frame4 bekommt der Ball durch eine erneute Tempohalbierung wieder seine wirkliche Geschwindigkeit. Diese Geschwindigkeitssprünge werden auch bei hoher Framerate noch als Ruckeln wahrgenommen. Man nennt diese Ruckler auch '''Mikroruckler'''. 
Als st-Diagramm dargestellt sieht das so aus: [[Datei:st-Diagramm_(Mikroruckler).png|300px]] 

==Bildschirmfrequenz und V-Sync==
Kein Bildschirm kann beliebig viele Bilder pro Sekunde darstellen. Eine übliche Refreshrate bei Flachbildschirmen ist 60 Hz (das heißt, das Bild wird 60 mal pro Sekunde erneuert). Es gibt aber auch welche mit 120 Hz (für [[Tutorial_StereoSehen|Stereoskopie]]) oder 200 Hz. Da 60 Hz auf Röhrenbildschirmen stark flimmern, können diese alten Kisten oft auch 75, 85, oder 100 Hz. Egal, wie oft ein Monitor pro Sekunde sein Bild erneuern kann - es gibt (von Ausnahmefällen wie [[Benchmark]]ing abgesehen) keinen Grund, die Grafikkarte mehr Bilder berechnen zu lassen, zumal dies zu unerwünschten Artefakten führt ([[V-Sync#Tearing|Tearing]]). 
Deshalb gibt es eine Technik, die sich [[V-Sync]] nennt. Dabei wartet die Grafikkarte, bis das neue Bild an den Bildschirm übertragen wurde, bis sie das nächste beginnt. Es ist unbedingt zu empfehlen V-Sync einzuschalten, wenn der Computer sowieso mehr Bilder pro Sekunde rendern kann als der Bildschirm darzustellen vermag. Doch was passiert, wenn V-Sync eingeschaltet ist und der Rechner nicht die native Framerate des Bildschirms erreicht? 
Nehmen wir an, der Bildschirm wird 60 mal pro Sekunde aktualisiert, die GPU schafft aber nur 50 Bilder pro Sekunde. Sobald die Grafikkarte das Synchronisationssignal empfängt, kopiert sie den Backbufferinhalt in den Frontbuffer und rendert das nächste Bild in den Backbuffer. 16,67 ms später kommt das nächste Synchronisationssignal, aber die Grafikkarte ist noch nicht fertig. Also wird nichts in den Frontbuffer kopiert. Stattdessen zeigt der Bildschirm zweimal hintereinander das gleiche Bild an. Erst weitere 3,33 ms später stellt der Grafikchip das Bild fertig und muss nun 13,34 ms (!) auf das nächste Sync-Signal warten. Bis dieses kommt, sind insgesamt 33,33 ms vergangen - mit anderen Worten wir haben eine Framerate von nur 30 fps, obwohl der Computer 50 fps schaffen würde! 
===Triple-Buffering===
Das Problem dabei ist, dass die Grafikkarte während des Wartens auf das Sync-Signal nichts tut. Doch dafür gibt es eine Lösung: Da wir in den Backbuffer noch nicht schreiben dürfen, schreiben wir halt in einen anderen Backbuffer! Während wir in den zweiten Backbuffer schreiben, wird der erste in den Frontbuffer kopiert, sobald das Sync-Signal wieder kommt. Im nächsten Frame schreiben wir natürlich wieder in den ersten Backbuffer, während der zweite aufs Kopieren wartet. Somit erreichen wir die selbe [[Performance]] wie ohne V-Sync, sind aber gleichzeitig das Tearing losgeworden. 
Ein Nachteil des Verfahrens ist, dass wir etwas mehr Videospeicher benötigen. Der Mehrverbrauch hält sich aber in Grenzen, denn es wird lediglich ein weiterer Farbpuffer benötigt - den [[Z-Buffer|Z-]] und [[Stencilbuffer]] dagegen brauchen wir nicht noch einmal. Zudem handelt man sich natürlich weitere Mikroruckler ein - aber mal ehrlich: 50 fps mit Mikrorucklern sind immer noch besser als 30 fps ohne. 
OpemGL bietet selbst keine Möglichkeit, Triple-Buffering an- oder auszuschalten. Dies ist Sache des Treibers. Man kann Triple-Buffering zwar mittels eines [[FBO]]s emulieren, jedoch hat man dann in Wirklichkeit Quadruple-Buffering, wenn der Treiber sich bereits darum kümmert. (Quelle: [http://www.opengl.org/wiki/Common_Mistakes#Triple_Buffering])
===variable Bildschirmfrequenz===
Aktuell (2014) gibt es in der Industrie Bestrebungen, Displays mit variabler Refreshrate zu entwickeln. Bezeichnungen dafür sind '''Adaptive Sync''' (DisplayPort-Standard), '''G-Sync''' (Nvidia) oder '''FreeSync''' (AMD). Dabei soll das Problem der Synchronisation zwischen Bildschirm und Grafikkarte von der anderen Seite als bisher angegangen werden: Nicht mehr der Bildschirm gibt vor, in welchem Takt die Grafikkarte Bilddaten liefern soll, sondern die Grafikkarte signalisiert dem Bildschirm, wann sie fertig mit den Berechnungen ist. Daraufhin überträgt sie das neue Bild an den Schirm, welcher es dann sofort darstellt. 
Der Vorteil: Die Latenz (Zeit zwischen Benutzereingabe und Bildausgabe) verkürzt sich, Triple-Buffering wird unnötig und die durch letzteres verursachten Mikroruckler verschwinden. Tearing sieht man ebenfalls nicht, da ja immer noch synchronisiert wird.

==Siehe auch==
[[Frameratenbegrenzung]] 
[[Framecounter]]

Framerate

2014-05-24T12:48:06Z

Glawesome: /* Triple-Buffering */ (Nicht-)Implementierung in OpenGL

Das englische Wort "frame" lässt sich in etwa mit "Rahmen" übersetzen. Das "Frame" in Framerate hat aber nichts mit einem Bilderrahmen o.ä. zu tun, sondern gemeint ist der zeitliche Rahmen, in dem ein bestimmter Rechenvorgang stattfindet. Wenn man von der Framerate von Spielen spricht, ist ein Frame also genau die Zeit, die der Computer benötigt, um ein neues Bild auf den Bildschirm zu rendern. Die Framerate (auch '''Bildwiederholrate''') gibt an, wie viele dieser Frames pro Sekunde (fps) vergehen.

==24 fps Mythos==
Damit die grafische Ausgabe nicht wie eine Abfolge von Einzelbildern, sondern wie eine flüssige Bewegung aussieht, muss das angezeigte Bild schnell genug aktualisiert werden - mit anderen Worten: Die Framerate muss hoch genug sein. Experimente haben ergeben, dass das menschliche Auge eine Animation ab etwa 24 Bildern pro Sekunde nicht mehr als Bildfolge, sondern als Bewegung wahrnimmt. Daher stammt auch die weit verbreitete Meinung, ein Spieler könne keinen Unterschied zwischen 24 fps und beispielsweise 60 fps erkennen. Diese Annahme ist jedoch aus verschiedenen Gründen falsch! Siehe folgender Text.

==Unschärfe bei Bewegung==
Überlegen wir einmal, was passiert, wenn ein weißer Ball schnell von links nach rechts durchs Bild fliegt. Das erste Bild, das der Computer rendert, zeigt den Ball auf der linken Seite des Bildes. [[Datei:Ball_links.png|400px]] 
Sofort nachdem das Bild fertig ist, misst das Programm natürlich die Zeit, die es für das eine Bild gebraucht hat (bei 24 fps knapp 42 ms). Anhand der gemessenen Zeit kann es bestimmen, welche Strecke der Ball in dieser Zeit zurückgelegt hat (s = v*t, [[Timebased Movement]]). Nun verschiebt es den Ball um die entsprechende Strecke und beginnt sofort, das nächste Bild zu rendern. Nun ist der Ball schon in der Mitte des Bildschirms angelangt. [[Datei:Ball_mittig.png|400px]] 
Wieder misst das Programm die vergangene Zeit, verschiebt den Ball um die entsprechende Strecke und rendert das nächste Bild. Nun ist der Ball rechts. [[Datei:Ball_rechts.png|400px]] 
Im nächsten Bild wird er gar nicht mehr zu sehen sein. Der Betrachter bekommt also hintereinander drei gestochen scharfe Bilder zu sehen, die er als Bewegung interpretieren soll. Das Problem dabei ist das "gestochen scharf". 
Betrachten wir zum Vergleich einmal, was passieren würde, wenn sich diese Szene in der Natur abspielt. Der Ball wird von einer oder mehrerer Lichtquellen beleuchtet und reflektiert einen Teil des Lichts zum Auge des Betrachters. (Der Einfachheit halber nehmen wir an, dass der arme Betrachter nur ein Auge hat.) Währenddessen bewegt sich der Ball, und da der Betrachter seine Blickrichtung in dieser Zeit nicht ändert, wird das Licht während des Frames von 42 ms an verschiedene Stellen der Netzhaut reflektiert - allerdings wird kein Teil der Netzhaut 42 ms lang belichtet. Über den Sehnerv wird für jeden "Pixel" auf der Netzhaut der mittlere Helligkeitswert ans Gehirn übermittelt. Das Resultat ist ein grauer (nicht weißer) Streifen quer durchs Bild. Der Ball "verwischt" sozusagen, wie man es auch von Fotos mit zu langer Belichtungszeit kennt. [[Datei:Ball_verwischt.png|400px]] 
Genau diese Unschärfe erwartet auch der Spieler eines Computerspiels. Fehlt dieser Effekt, wirkt die Bewegung ruckelig. Eine Möglichkeit, diesen Effekt zu erzielen, wäre alle Bewegungen unscharf zu zeichnen. Das hat aber einen gewaltigen Nachteil, wie du im nächsten Abschnitt sehen wirst. Die andere Möglichkeit ist, einfach deutlich mehr Bilder pro Sekunde zu rendern, als nur 24.

==Schärfe bei Bewegung==
Warum ist das Unscharf-Zeichnen ([[Motion-Blur]]) keine Lösung des Problems? Ganz einfach: Man stelle sich die selbe Szene noch einmal vor - mit dem einzigen Unterschied, dass der Betrachter dieses Mal nicht auf eine Stelle starrt, sondern den Ball mit seinem Blick verfolgt. Er sieht also erst auf die linke Seite des Bildschirms und bewegt seinen Blick mit konstanter Geschwindigkeit nacht rechts. Was würde er erwarten zu sehen? Denk' mal kurz darüber nach. 
Der Spieler erwartet natürlich die selben Effekte, die er (unbewusst) zuvor in der Natur beobachtet hat. Nämlich dass der fliegende Ball gestochen scharf zu sehen ist, während der Hintergrund in Unschärfe verwischt. Denn dadurch, dass der Beobachter sein Auge immer nach dem Ball ausrichtet, trifft das von ihm reflektierte Licht immer die gleichen Stellen der Netzhaut. 
Dem Ball auf dem Bildschirm zu folgen, nachdem dieser unscharf gezeichnet wurde, geht aber nicht - man sieht ja nur einen grauen Streifen, überall dort, wo der Ball im Laufe des Frames einmal war. Das Problem ist, dass der Programmierer nicht wissen kann, wie der oder die Betrachter des Bildschirms ihre Augen bewegen.
Würde man die gesamte Szene ohne Motion-Blur aber mit 24000 fps rendern (was natürlich kein PC oder Bildschirm schaffen würde), dann würde sich der Ball in jedem Frame um einen oder zwei Pixel verschieben und wäre zu jeder Zeit gestochen scharf, wenn man ihm folgt. Gleichzeitig würde er (für das Auge) verwischen, wenn man ihm nicht folgt. 
Die einzige Möglichkeit, dem Spieler ein wirklich realistisches visuelles Erlebnis zu bieten, besteht also darin, eine möglichst hohe Framerate zu erzielen. Eine geringe Framerate lässt sich im Allgemeinen nicht mit Motion-Blur kompensieren. Der Blur-Effekt kostet sogar noch Leistung und sorgt damit für eine geringere Framerate (das gilt natürlich nicht in Filmen). Dennoch hat Motion-Blur seine Existenzberechtigung: Erstens wenn die FPS-Grenze des Monitors bereits erreicht ist. Und zweitens um Dinge mit übertriebenem Motion-Blur schneller aussehen zu lassen, als sie sind.

==Variation der Framerate==
Auch wenn die Framerate deutlich über 24 fps liegt, können selbst langsamere Bewegungen noch ruckelig wirken. Grund dafür ist dann, dass die Framelänge stark variiert. Als Beispiel muss mal wieder der Ball herhalten, der diesmal aber nicht in einer achtel Sekunde durchs gesamte Bild fliegt, sondern gemächlich mit konstanter Geschwindigkeit ins Bild rollt. Die Szene wird mit (normalerweise sehr flüssigen) 60 fps gerendert. Ein Frame hat also eine Dauer von 16,67 ms. Leider kommt es nun durch ungünstige Umstände dazu, dass ein einziges Frame plötzlich doppelt so lange dauert wie die anderen zuvor. Welche Auswirkungen hat also folgende Frame-Abfolge? 
{| border="1" rules="all"
! Frame
! Länge
|-
| Frame0
| 16,67
|-
| Frame1
| 16,67
|-
| Frame2
| 33,33
|-
| Frame3
| 16,67
|-
| Frame4
| 16,67
|} 
Die Hälfte von 60 fps sind 30 fps. Man sollte meinen, dass dies immer noch als ruckelfrei empfunden wird. Das Problem ist auch nicht die Framelänge als solches, sondern die Länge von Frame2 im Vergleich zu den anderen Frames. Der Betrachter erwartet, dass der Ball mit konstanter Geschwindigkeit weiterrollt. Während das Bild gezeichnet wird, kann das Programm noch nicht wissen, wie viel Zeit vergangen sein wird, wenn das Bild fertig ist. Deshalb wird der Ball ja immer um die Strecke verschoben, die der letzten Framelänge entspricht. In Frame2 wird also der Ball verschoben, als wenn der Zeichenvorgang nur 16,67 ms dauern würde. In Wirklichkeit vergeht aber doppelt so viel Zeit, so dass es dem Spieler vorkommt, als hätte der Ball seine Geschwindigkeit plötzlich halbiert. Aber es kommt noch schlimmer: Da Frame3 wieder nur 16,67 ms dauert, der Ball aber so weit fortbewegt wird, als würde der Frame 33,33 ms dauern, vervierfacht sich die Geschwindigkeit nun! Erst in Frame4 bekommt der Ball durch eine erneute Tempohalbierung wieder seine wirkliche Geschwindigkeit. Diese Geschwindigkeitssprünge werden auch bei hoher Framerate noch als Ruckeln wahrgenommen. Man nennt diese Ruckler auch '''Mikroruckler'''. 
Als st-Diagramm dargestellt sieht das so aus: [[Datei:st-Diagramm_(Mikroruckler).png|300px]] 

==Bildschirmfrequenz und V-Sync==
Kein Bildschirm kann beliebig viele Bilder pro Sekunde darstellen. Eine übliche Refreshrate bei Flachbildschirmen ist 60 Hz (das heißt, das Bild wird 60 mal pro Sekunde erneuert). Es gibt aber auch welche mit 120 Hz (für [[Tutorial_StereoSehen|Stereoskopie]]) oder 200 Hz. Da 60 Hz auf Röhrenbildschirmen stark flimmern, können diese alten Kisten oft auch 75, 85, oder 100 Hz. Egal, wie oft ein Monitor pro Sekunde sein Bild erneuern kann - es gibt (von Ausnahmefällen wie [[Benchmark]]ing abgesehen) keinen Grund, die Grafikkarte mehr Bilder berechnen zu lassen, zumal dies zu unerwünschten Artefakten führt ([[V-Sync#Tearing|Tearing]]). 
Deshalb gibt es eine Technik, die sich [[V-Sync]] nennt. Dabei wartet die Grafikkarte, bis das neue Bild an den Bildschirm übertragen wurde, bis sie das nächste beginnt. Es ist unbedingt zu empfehlen V-Sync einzuschalten, wenn der Computer sowieso mehr Bilder pro Sekunde rendern kann als der Bildschirm darzustellen vermag. Doch was passiert, wenn V-Sync eingeschaltet ist und der Rechner nicht die native Framerate des Bildschirms erreicht? 
Nehmen wir an, der Bildschirm wird 60 mal pro Sekunde aktualisiert, die GPU schafft aber nur 50 Bilder pro Sekunde. Sobald die Grafikkarte das Synchronisationssignal empfängt, kopiert sie den Backbufferinhalt in den Frontbuffer und rendert das nächste Bild in den Backbuffer. 16,67 ms später kommt das nächste Synchronisationssignal, aber die Grafikkarte ist noch nicht fertig. Also wird nichts in den Frontbuffer kopiert. Stattdessen zeigt der Bildschirm zweimal hintereinander das gleiche Bild an. Erst weitere 3,33 ms später stellt der Grafikchip das Bild fertig und muss nun 13,34 ms (!) auf das nächste Sync-Signal warten. Bis dieses kommt, sind insgesamt 33,33 ms vergangen - mit anderen Worten wir haben eine Framerate von nur 30 fps, obwohl der Computer 50 fps schaffen würde! 
===Triple-Buffering===
Das Problem dabei ist, dass die Grafikkarte während des Wartens auf das Sync-Signal nichts tut. Doch dafür gibt es eine Lösung: Da wir in den Backbuffer noch nicht schreiben dürfen, schreiben wir halt in einen anderen Backbuffer! Während wir in den zweiten Backbuffer schreiben, wird der erste in den Frontbuffer kopiert, sobald das Sync-Signal wieder kommt. Im nächsten Frame schreiben wir natürlich wieder in den ersten Backbuffer, während der zweite aufs Kopieren wartet. Somit erreichen wir die selbe [[Performance]] wie ohne V-Sync, sind aber gleichzeitig das Tearing losgeworden. 
Ein Nachteil des Verfahrens ist, dass wir etwas mehr Videospeicher benötigen. Der Mehrverbrauch hält sich aber in Grenzen, denn es wird lediglich ein weiterer Farbpuffer benötigt - den [[Z-Buffer|Z-]] und [[Stencilbuffer]] dagegen brauchen wir nicht noch einmal. Zudem handelt man sich natürlich weitere Mikroruckler ein - aber mal ehrlich: 50 fps mit Mikrorucklern sind immer noch besser als 30 fps ohne. 
OpemGL bietet selbst keine Möglichkeit, Triple-Buffering an- oder auszuschalten. Dies ist Sache des Treibers. Man kann Triple-Buffering zwar mittels eines [[FBO]]s emulieren, jedoch hat man dann in Wirklichkeit Quadruple-Buffering, wenn der Treiber sich bereits darum kümmert. (Quelle: [http://www.opengl.org/wiki/Common_Mistakes#Triple_Buffering])

==Siehe auch==
[[Frameratenbegrenzung]] 
[[Framecounter]]

Tutorial SDL2 Installation

2014-05-14T07:06:16Z

Glawesome: Code::Blocks (C++) auf Linux

{{Unvollständig|Andere Programmiersprachen/IDEs/Betriebssysteme sollten hier nachgetragen werden.}}

In diesem Tutorial wird dir gezeigt, wie du deine Entwicklungsumgebung so einrichtest, dass du SDL2-Programme entwickeln kannst. Dies ist Voraussetzung für [[Tutorial OpenGL3 Lektion 1]]. Auch wenn das Prinzip überall gleich ist, hängen die Details von der jeweils verwendeten Programmiersprache, von der Entwicklungsumgebung und vom Betriebssystem ab. Daher ist der Rest des Artikels nach Programmiersprache und IDE aufgeteilt.

==Code::Blocks (C++) unter Windows==
===SDL2 herunterladen===
Das erste, was wir benötigen, ist die Library SDL2 selbst. Diese lädst du dir [https://www.libsdl.org/download-2.0.php hier] herunter. Da wir Entwickler sind, brauchen wir nur, was im Abschnitt "Development Libraries" angeboten wird. Wer [http://www.codeblocks.org/ Code::Blocks] einsetzt, verwendet in der Regel den MinGW-Compiler. Dies ist dann der Fall, wenn man den Compiler gleichzeitig mit Code::Blocks installiert hat. Ist dies der Fall, speichert man als die Datei "SDL2-devel-2.0.3-mingw.tar.gz" auf dem Computer. Die Versionsnummer kann sich natürlich schon geändert haben, wenn du dieses Tutorial liest. Solange sie mit 2.0 beginnt, sollte alles so funktionieren, wie hier beschrieben.
===Archiv entpacken===
Die heruntergeladene Datei ist ein Archiv, also eine Datei in der weitere Dateien und Ordner komprimiert gespeichert sind. Schließlich wäre es mühsam, 100 Dateien einzeln herunterzuladen, nicht wahr? ;) Um das Archiv zu entpacken, benötigst du ein Archivprogramm auf deinem Computer. Auf den meisten Computern ist das ohnehin installiert. Falls dies bei dir nicht der Fall ist, kann ich [http://www.7-zip.org/ 7-zip] empfehlen, welches kostenlos (sogar open-source) ist und sehr viele Formate lesen und schreiben kann - insbesondere auch das Format tar.gz. Wenn du das heruntergeladene Archiv entpackt hast, befindet sich auf deiner Festplatte ein Ordner "SDL2-2.0.3" (oder eine andere Versionsnummer).
===Die richtigen Dateien am richtigen Ort===
Damit der Compiler die heruntergeladenen Code-Dateien auch findet, müssen wir ihm sagen, wo sich diese befinden. Ich rate davon ab, das lokale Downloadverzeichnis (wo sich die Dateien bei dir vermutlich jetzt befinden) als Include-Pfad zu verwenden. Suche dir ein Verzeichnis auf der Festplatte aus, der deinem Ordnungssystem entspricht - auf deinem Computer herrscht doch Ordnung, oder?! ;) 
Der Einfachheit halber werde ich im Folgenden einfach annehmen, dass das Verzeichnis ''C:\include'' heißt. Darin erstellst du nun einen Ordner namens "SDL2". Nun wechselst du in das von dir entpackte Verzeichnis nach ''SDL2-2.0.3\include'' und kopierst alle darin enthaltenen Dateien nach ''C:\include''. 
Außerdem brauchen wir noch ein zweites Verzeichnis für Linker-Dateien. Dieses nenne ich hier einfach mal ''C:\lib''. Dorthin werden alle .a-Dateien kopiert, die sich im Ordner ''SDL2-2.0.3\i686-w64-mingw32\lib'' (wenn dein Programm 32bit ist) bzw. ''SDL2-2.0.3\x86_64-w64-mingw32\lib'' (falls du ein 64bit-Programm schreibst) befinden. Falls du unsicher bist, brauchst du wahrschenlich die 32bit-Version - auch wenn dein Betriebssystem 64bittig ist!

===Projekteinstellungen===
Falls noch nicht geschehen, startest du nun Code::Blocks und erstellst ein neues Projekt (Konsolenanwendung, "Hello World"-Beispiel). Um sicherzugehen, dass alles andere funktioniert, kompilierst du deine Anwendung erstmal und führst sie aus. 
Ist dies erfolgreich, klickst du im Menü auf "Project" -> "Build options..." und wählst in dem sich öffnenden Fenster den Reiter "Search directories". Dieser enthält wiederum zwei Unterreiter "Compiler" und "Linker". Beim Unterreiter "Compiler" klickst du auf "Add" und wählst ''C:\include'' aus. Auf die gleiche Weise wählst du beim Unterreiter "Linker" das Verzeichnis ''C:\lib'' aus.
Danach wechselst du noch zum Reiter "Linker settings" (neben "Search directories") und fügst folgende Zeile in die Box "other linker options" ein:
-lmingw32 -lSDL2main -lSDL2 -lopengl32
Anschließend natürlich noch mit einem Klick auf OK bestätigen. 

Folgender Code sollte nun erfolgreich gebaut (kompiliert und gelinkt) werden können:
<source lang=cpp>#include <iostream>
#include <SDL2/SDL.h>

int main(int argc, char* args[])
{
if(SDL_Init(SDL_INIT_EVERYTHING) != 0)
std::cout << "SDL_Init failed!\n";
else
std::cout << "SDL_Init was successful!\n";

SDL_Quit();
return 0;
}</source>

===DLL-Fehlermeldung===
Bevor du jetzt laut "Fehlermeldung!" stöhnst: Ich sagte bauen, nicht ausführen ;) Die Ausführung funktioniert in der Tat noch nicht, da Windows bei der Ausführung des Programms vergeblich nach der Datei "SDL2.dll" sucht. Diese musst du erst noch in das Verzeichnis kopieren, in dem sich die exe-Datei deines Programms befindet. Du findest sie im Ordner ''SDL2-2.0.3\lib\x86'' (32bit) bzw. in ''SDL2-2.0.3\lib\x64'' (64bit).

==Code::Blocks (C++) auf Linux==
===SDL2 herunterladen===
Die meisten Linux-Distributionen bieten die benötigte SDL2-Library bereits im Standard-Repository an. Unter [https://www.opensuse.org/ openSuSE] z.B. startet man einfach YaST und klickt auf "Software installieren oder löschen". Im sich nun öffnenden Fenster suchst du nach "SDL2". Die Pakete "libSDL2-2_0-0" und "libSDL2-devel" sind für uns interessant. Für spätere Tutorials könnten auch "libSDL2_image-2_0-0" und "libSDL2_image-devel" nützlich sein. Nach einem Klick auf "Akzeptieren" werden die ausgewählten Paket installiert. Auf anderen Linux-Distributionen sind die Schritte ähnlich und die Pakete sollten alle "SDL2" im Namen enthalten.

===Projekteinstellungen===
Nach der Installation landen die SDL2-Headerdateien üblicherweise in ''/usr/include/SDL2/''. Dieser Pfad muss in Code::Blocks nicht extra angegeben werden, sondern wird normalerweise automatisch gefunden. Jedoch muss noch eine Linker-Einstellung gemacht werden. Dazu wählst du im Menü "Project" den Eintrag "Build options..." und wählst im sich öffnenden Fenster den Reiter "Linker settings". Im Feld "other linker options" tippst du folgende Zeile ein:
-ldl -lGL -lSDL2main -lSDL2
Nun solltest du folgenden Code problemlos kompilieren und ausführen können:
<source lang=cpp>#include <iostream>
#include <SDL2/SDL.h>

int main(int argc, char* args[])
{
if(SDL_Init(SDL_INIT_EVERYTHING) != 0)
std::cout << "SDL_Init failed!\n";
else
std::cout << "SDL_Init was successful!\n";

SDL_Quit();
return 0;
}</source>

==Delphi / Lazarus unter Windows==
Für Delphi und Lazarus sind alle Schritte gleich, es gibt dann lediglich einen Unterschied beim Eintragen des Pfades im Compiler. Deswegen hier die Zusammenfassung für beide Compiler.

===SDL2 herunterladen===
Wir benötigen natürlich auch erst einmal die Library SDL2, diese gibt es auch für uns auf der offiziellen [http://www.libsdl.org SDL Seite]. Allerdings brauchen wir von hier lediglich die ''SDL2.dll'' mit den Programmfunktionen, also nehmen wir das entsprechende Paket der ''Runtime Libraries für Windows''. Im weiteren Verlauf gehen wir mal von der Datei ''SDL2-2.0.3-win32-x86.zip'' aus. Die Versionsnummer kann sich natürlich in Zukunft ändern. Wichtig ist nur, dass das Archiv mit "SDL2-2." beginnt. Die 64-Bit Version benötigt man übrigens nur wenn man echte 64-Bit Programme erzeugt, also NICHT weil man ein 64-Bit Betriebssystem benutzt.

Zusätzlich benötigen wir jetzt noch Header-Dateien für Pascal, unser Compiler möchte ja auch gerne wissen, was so alles in der SDL2.dll enthalten ist ;-) Wir benutzen die Pascal-Portierung der SDL2 Header, die [http://www.delphigl.com/forum/viewtopic.php?f=13&t=10752 hier] erhältlich sind. Auf der GitHub-Seite angekommen schauen wir auf der rechten Seite, dort gibt es eine Schaltfläche "Download ZIP", mit der man die Datei "Pascal-SDL-2-Headers-master.zip" erhält.

===Archive entpacken===
Falls noch kein geeignetes Programm zum Entpacken von ZIP-Dateien vorhanden ist -> [http://www.7-zip.org/ 7-Zip].
Wenn ein anderes Programm benutzt wird solltest Du ja wissen, wie die Archive damit zu entpacken sind. Mit 7-Zip machen wir einen Rechtsklick auf das Archiv und wählen aus dem erscheinenden Kontextmenü "7-Zip", es sollte dann ein Untermenü mit weiteren Befehlen erscheinen. Hier wählen wir entweder "Hier entpacken" oder "Entpacken nach <Archivname>", besser ist die zweite Option. Damit wird in jedem Fall ein Unterordner erzeugt, der so heißt wie das Archiv und in dem sich dann die entpackten Dateien befinden. Nach dem Entpacken sollten also 2 Unterordner vorhanden sein, einer namens ''Pascal-SDL-2-Headers-master'' und einer namens ''SDL2-2.0.3-win32-x86''.

===Die richtigen Dateien am richtigen Ort===
Wenn Du schon andere Fremdbibliotheken verwendest, gibt es bei Dir bestimmt einen extra Ordner dafür, im weiteren Verlauf verwenden wir mal ''C:\Library\''. In diesem erstellen wir jetzt beispielsweise einen Unterordner ''SDL2'' und kopieren/verschieben den Inhalt des entpackten Ordners ''Pascal-SDL-2-Headers-master'' hinein. Der Pfad zur Datei ''sdl2.pas'' sieht jetzt also so aus: ''C:\Library\SDL2\sdl2.pas''. Damit haben wir die Header schon mal an einem sinnvollen Ort.

Der Inhalt des zweiten Archivs mit der ''SDL2.dll'' wird im Projektverzeichnis deiner Anwendung benötigt, genauer: Dort wo deine ausführbare Datei erstellt wird. Wenn Du also beispielsweise ein Projekt in ''C:\Projekte\Beispiel\'' hast und deine exe-Datei dort erstellt wird, müssen die Dateien des entpackten Ordners ''SDL2-2.0.3-win32-x86'' dort hinein. Wenn im Projektordner Unterordner wie ''Debug'', ''Release'' usw. für das Erstellen der ausführbaren Datei benutzt werden, muss die ''SDL2.dll'' natürlich dort hinein.

===Compilereinstellungen===
Um dem verwendeten Compiler nun die Library SDL2 bekannt zu machen, müssen wir ihm mitteilen in welchem Ordner wir die Header haben. Wie schon oben erwähnt gehen wir davon aus, das der Pfad ''C:\Library\SDL2\'' lautet.

====Delphi====
Hier am Beispiel für Delphi 2009, in anderen Versionen sollte das ähnlich sein.
Im Menü wählen wir "Tools" -> "Optionen", im erscheinenden Fenster wählen wir "Umgebungsoptionen" -> "Delphi-Optionen" -> "Bibliothek - Win32". Auf der rechten Seite wird dann der "Bibliothekspfad" angezeigt, wir drücken die Schaltfläche "..." rechts davon. Im erscheinenden Fenster "Verzeichnisse" drücken wir dann wieder die Schaltfläche "...", nun erscheint ein Explorerfenster in dem wir in den Ordner ''C:\Library\SDL2'' auswählen und bestätigen. Im Fenster "Verzeichnisse" danach nicht vergessen auf "Hinzufügen" zu drücken, dann mit "OK" das Fenster schließen. Abschließend im Fenster "Optionen" auch mit "OK" bestätigen. SDL2 kann nun in jedem Projekt verwendet werden, es muss hier nichts mehr in den Projekt-Optionen eingestellt werden.

====Lazarus====
Hier am Beispiel für Lazarus 1.2.0, in anderen Versionen sollte das ähnlich sein.
Im Gegensatz zu Delphi gibt es keine mir bekannte Möglichkeit SDL2 generell für alle Projekte verfügbar zu machen. Wir müssen also erst einmal ein Projekt erstellt haben und können dann SDL2 für dieses Projekt folgendermaßen verfügbar machen: Im Menü wählen wir "Projekt" -> "Projekteinstellungen", im sich öffnenden Fenster wählt man "Compilereinstellungen" -> "Pfade". Rechts ist nun der Punkt "Andere Units..." zu sehen. Analog zu Delphi drücken wir rechts daneben die Schaltfläche "...", es erscheint das Fenster "Pfadeditor". Dort die Schaltfläche mit einem gelben Ordnersymbol drücken, im erscheinenden Auswahldialog nun den Ordner ''C:\Library\SDL2'' wählen und mit "OK" bestätigen. Im Fenster "Pfadeditor" danach nicht vergessen auf "Hinzufügen" zu drücken, dann mit "OK" das Fenster schließen. Abschließend im Fenster "Einstellungen für Projekt..." auch mit "OK" bestätigen. Nun kann SDL2 in diesem Projekt verwendet werden.

Der folgende Code sollte nun kompiliert und ausgeführt werden können, vorausgesetzt Du hast nicht vergessen die ''SDL2.dll'' in den Projektordner zu kopieren:

<source lang=pascal>program Project1;

{$APPTYPE CONSOLE}

uses SysUtils, SDL2;

begin
if SDL_Init(SDL_INIT_EVERYTHING) <> 0 then
WriteLn('SDL2 Initialisierung fehlgeschlagen!')
else
WriteLn('SDL2 erfolgreich initialisiert!');
SDL_Quit();
Sleep(2000);
end.
</source>

===DLL-Fehlermeldung===
Solltest Du beim Starten deines Programms eine Fehlermeldung bekommen (The program can't start because SDL2.dll is missing...) liegt das daran, das die SDL2-dll nicht gefunden wurde. Wie schon oben erwähnt muss diese in den gleichen Ordner kopiert werden wo deine exe-Datei ist.

[[Kategorie:Tutorial|SDL2 Installation]]

Rasterizer

2014-04-29T16:01:05Z

Glawesome: Weiterleitung nach Rasterisierung erstellt

#REDIRECT: [[Rasterisierung]]

Blenderscript

2014-04-21T09:39:06Z

Glawesome: /* Blender exporter Script */ Python-Code in <source>-Block gepackt (für Syntaxhighlighting)

==Blender exporter Script==

Folgendes Blenderscript, welches in Python geschrieben ist, exportiert [[Mesh]], Texturkoordinaten und Normalen. Es wurde von [[Benutzer:TAK2004|TAK2004]] geschrieben welcher es euch hiermit freistellt dieses zu erweitern, anzupassen oder einfach zu kopieren.
Zur Bedienung ist folgendes zu sagen:
*es ist auf korrekte Einrückung zu achten, da dadurch Codeblöcke, Funktionen und Einsprungspunkte erkannt werden
*die Datei wird an dem am Ende eingetragen Punkt gespeichert
*bevor das Script im File->Export Menü erscheint muss das Script einmal interpretiert werden
*ein Script kann über ein Textfenster in Blender angezeigt und gestartet werden
*das Script achtet nicht auf die Rotation der Objekte, deswegen ist anzuraten durch folgende Tastenkombinationen die Objekte neu auszurichten : "a"(wählt alle Objekte aus/ab),"strg+s"(tranformiert Objektrotation mit dem Mesh und setz dann die rotation auf 0)
*es müssen Lichter,Empty und Kameras entfernt werden da diese sonst als Objekte interpretiert und falsch behandelt werden

<source lang="python">#!BPY

"""
Name: '... Meshformat (.meshf)...'
Blender: 234
Group: 'Export'
Tooltip: 'Exportiert die aktuelle Szene in das ... Format'
"""

import struct
import Blender
import sys

from Blender import NMesh
from Blender import Image
from Blender.NMesh import *
from Blender.Image import *

class TFace:
vertstart=0
vertcount=0

class TObject:
posx=0
posy=0
posz=0
facestart=0
facecount=0

class meshf:
#header
Version="meshf1"
NumOfVert=0
NumOfFace=0
NumOfObj=0
#data

Verts=[]
Faces=[]
Meshs=[]
Texcoords=[]

size=0

file=meshf

#Funktion zum schreiben des Headers
def writeheader():
iof.write(file.Version)
data=struct.pack("iii",file.NumOfVert,
file.NumOfFace,
file.NumOfObj)
iof.write(data)

#Funktion zum schreiben des Datenteils
def writedata():

#Verticekoordinaten
for v in file.Verts:
data=struct.pack("fff",v.co[0],v.co[1],v.co[2])
file.size=file.size+12
iof.write(data)

#Normalen
for v in file.Verts:
data=struct.pack("fff",v.no[0],v.no[1],v.no[2])
file.size=file.size+12
iof.write(data)

#Texkoordinaten
for t in file.Texcoords:
data=struct.pack("ff",t[0],t[1])
file.size=file.size+8
iof.write(data)

#Flächen
for f in file.Faces:
#vertstart,vertcount
data=struct.pack("ii",f.vertstart,f.vertcount)
iof.write(data)
file.size=file.size+8

#Objekte
for o in file.Meshs:
data=struct.pack("fff",o.posx,o.posy,o.posz)
iof.write(data)
data=struct.pack("ii",o.facestart,o.facecount)
iof.write(data)

#Funktion zum lesen der Blender Daten
def readblenderdata():
#lade alle Objekte in objs
objs=Blender.Object.Get()
#geht alle Objekte in objs durch
for obj in objs:
#holt sich die Meshdaten und speichert sie
mesh=obj.getData()
facecount=file.NumOfFace
file.NumOfFace=file.NumOfFace+len(mesh.faces)

for f in mesh.faces:
if len(f.v)==4:#wenn die Fläche aus 4 Vertice besteht
file.Verts.append(f.v[0])
file.Verts.append(f.v[1])
file.Verts.append(f.v[2])
fa=TFace()
fa.vertstart=len(file.Verts)-3
fa.vertcount=3
file.Faces.append(fa)

file.Verts.append(f.v[0])
file.Verts.append(f.v[2])
file.Verts.append(f.v[3])
fa=TFace()
fa.vertstart=len(file.Verts)-3
fa.vertcount=3
file.Faces.append(fa)

file.NumOfFace=file.NumOfFace+1
file.NumOfVert=file.NumOfVert+6

if len(f.uv)==0:
file.Texcoords.append([0,0])
file.Texcoords.append([0,0])
file.Texcoords.append([0,0])
file.Texcoords.append([0,0])
file.Texcoords.append([0,0])
file.Texcoords.append([0,0])
else:
file.Texcoords.append((f.uv[0][0],f.uv[0][1]))
file.Texcoords.append((f.uv[1][0],f.uv[1][1]))
file.Texcoords.append((f.uv[2][0],f.uv[2][1]))
file.Texcoords.append((f.uv[0][0],f.uv[0][1]))
file.Texcoords.append((f.uv[2][0],f.uv[2][1]))
file.Texcoords.append((f.uv[3][0],f.uv[3][1]))

if len(f.v)==3:#wenn die Fläche aus 3 Vertice besteht
for ve in f.v:
file.Verts.append(ve)
file.NumOfVert=file.NumOfVert+len(f.v)
fa=TFace()
fa.vertstart=len(file.Verts)-3
fa.vertcount=3
file.Faces.append(fa)

if len(f.uv)==0:
file.Texcoords.append([0,0])
file.Texcoords.append([0,0])
file.Texcoords.append([0,0])
else:
for tc in f.uv:
file.Texcoords.append((tc[0],tc[1]))

ob=TObject()
ob.posx=obj.LocX
ob.posy=obj.LocY
ob.posz=obj.LocZ
ob.facestart=facecount
ob.facecount=file.NumOfFace-facecount
file.Meshs.append(ob)

#Objektanzahl erhoehen
file.NumOfObj=file.NumOfObj+1

print "start"
#Open File
iof=open("C:/Medien/player.xdp","wb")

#holt die Szenendaten
readblenderdata()

#schreibt den Header der Datei
writeheader()

#schreibt den Datenteil der Datei
writedata()

#Datei schliessen
iof.close()

print "Flaechen:"+str(file.NumOfFace)
print "Vertice:"+str(file.NumOfVert)
print "ready Size:"+str(file.size)</source>

Rasterisierung

2014-04-16T12:29:22Z

Glawesome:

Bei der Rasterisierung werden aus den bisher gesammelten geometrischen Daten, die in den [[Viewport]] gemappt wurden, die [[Fragment]]e generiert, welche dann alle für eine Bildschirmkoordinate benötigten Daten beinhalten. Dazu wird die Primitive (hier: gelbes Dreieck) über das Pixelraster des Viewports gelegt. Alle Fragmente, die zu mindestens 50% von der Primitve verdeckt werden (grün ausgefüllt), werden im Folgenden weiter behandelt. Die anderen werden verworfen.

[[Bild:Rasterizing.png|310px]]

Rasterisierung findet nach dem [[Vertexshader|Vertex-]] und ggf. [[Geometryshader]] statt. Danach werden noch per-Fragment Operationen ([[Tiefentest|Z-Test]], [[Feste_Funktionspipeline#Alpha_Test|Alpha Test]], [[Feste_Funktionspipeline#Stencil_Test|Stencil Test]], [[Fragmentshader]], [[Blending]] etc.) für jedes gerasterte (grün ausgefüllte) Fragment durchgeführt, bevor aus dem Fragment dann ein [[Pixel]] im [[Farbpuffer]] wird.

Rasterisierung

2014-04-16T12:26:51Z

Glawesome: Bild eingefügt, ein paar Textergänzungen

Bei der Rasterisierung werden aus den bisher gesammelten geometrischen Daten, die in den [[Viewport]] gemappt wurden, die [[Fragment]]e generiert, welche dann alle für eine Bildschirmkoordinate benötigten Daten beinhalten. Dazu wird die Primitive (hier: gelbes Dreieck) über das Pixelraster des Viewports gelegt. Alle Fragmente, die zu mindestens 50% von der Primitve verdeckt werden (grün ausgefüllt), werden im Folgenden weiter behandelt.

[[Bild:Rasterizing.png|310px]]

Rasterisierung findet nach dem [[Vertexshader|Vertex-]] und ggf. [[Geometryshader]] statt. Danach werden noch per-Fragment Operationen ([[Tiefentest|Z-Test]], [[Feste_Funktionspipeline#Alpha_Test|Alpha Test]], [[Feste_Funktionspipeline#Stencil_Test|Stencil Test]], [[Fragmentshader]], [[Blending]] etc.) durchgeführt, bevor aus dem Fragment dann ein [[Pixel]] im [[Farbpuffer]] wird.

Datei:Rasterizing.png

2014-04-16T12:13:57Z

Glawesome:

Tutorial Allgemeines

2014-04-16T08:44:02Z

Glawesome: /* Rendertechniken */

Auf dieser Seite sind alle Tutorials von DGL aufgelistet, die nicht direkt etwas mit OpenGL zu tun haben. Dennoch sind die Inhalte für die meisten OpenGL-Entwickler durchaus relevant. Wer etwas über OpenGL selbst lernen will, sollte sich [[Tutorial GL3+]] ansehen. Außerdem gibt es noch eine ganze Menge lesenswerte aber veraltete Tutorials im Artikel [[Tutorial deprecated OpenGL]].

=Tutorials=
{{Hinweis|Alle Tutorials sind der [[:Kategorie:Tutorial]] zugeordnet.}}

<div align="center">
{|{{Prettytable_B1}} width="100%"
!width="15%"|Schwierigkeitsgrad
!Bedeutung
|-
|{{Level_1}}
|Jeder Schritt wird ausführlich erklärt. Absolut Einsteigertauglich.
|-
|{{Level_2}}
|Verständnis der Grundprinzipien wird voraus gesetzt. Die Materie bleibt aber einfach.
|-
|{{Level_3}}
|Ihr wisst um was es geht. Es wird erwartet, dass ihr selbst das Thema weiterdenkt.
|-
|{{Level_4}}
|Das Tutorial bietet euch einen Einstieg. Es wird erwartet, dass ihr euch selbst noch eingehender mit den beschriebenen Techniken befasst. Für Fragen steht unser Forum zur Verfügung.
|-
|{{Level_5}}
|Um das Tutorial zu verstehen werden Kenntnisse auf dem entsprechenden Gebiet vorausgesetzt, welche über Grundwissen hinausgehen. Es wird erwartet, dass ihr euch eingehender mit dem Thema auseinandersetzt und auch andere Quellen lest/gelesen habt. Für Fragen steht unser Forum zur Verfügung.
|}
</div>

== KI ==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial pathfinding|Tutorial Pathfinding]]
{{Level_2}}
|[[Bild:Tutorial_pathfinding.png|right]] "Pathfinding 1". 
In diesem Tutorial zeigt euch Flo wie man recht simpel eine Wegfindungsroutine implementiert. Besonders wenn man sowas ohne großen Lernaufwand in sein Spiel einbinden möchte, sollte man einen Blick riskieren.
|-
![[Tutorial pathfinding2|Tutorial Pathfinding 2]]
{{Level_3}}
|[[Bild:Tutorial_pathfinding2.png|right]] "Pathfinding 2". 
Gerade bei aktuelleren Programmen reicht es meist nicht aus, wenn man seine Einheiten nur in 8 Himmelsrichtungen bewegen kann. Frase stellt in diesem Tutorial vor, wie man eine Wegfindungsroutine implementieren kann, wie diese in einem heutigen RTS vorkommen kann.
|-
|}

== Spieletutorials und Softwareentwicklung==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial Bomberman1|Tutorial Bomberman 1]]
{{Level_3}}
|[[Bild:Tutorial_Bomberman1.jpg|right]] "Bomberman1 - Codebasis und Editor". 
Im ersten Teil dieser kleinen Tutorialserie zum Thema Spieleprogrammierung kümmern wir uns neben der Erstellung unseres Basiscodes auch um einen fertigen Editor. Nach der Durcharbeitung dieses Tutorials von Sascha Willems sollte der Leser alle Grundprinzipien zur Programmierung eines Spiels verstanden haben.
|-
![[Tutorial Bomberman2|Tutorial Bomberman 2]]
{{Level_3}}
|[[Bild:Tutorial_Bomberman2.jpg|right]] "Bomberman2 - Der 3D-Bombermanklon (Grundversion)". 
Im zweiten Teil gehts ans Eingemachte, nämlich einen fertigen Bombermanklon. In Sascha Willems Tutorial werdet ihr zusätzlich zu den bereits erworbenen Prinzipien diverse Techniken die in so ziemlich jedem Spiel Verwendung finden erlernen.
|-
![[Tutorial Softwareentwicklung1|Tutorial Softwareentwicklung 1]]
{{Level_3}}
|[[Bild:Tutorial_SWE1.jpg|right]] "Softwareentwicklung1 - Objektorientierte Softwareentwicklung mit UML". 
Im ersten Teil dieser Tutorialserie zum Thema Softwareentwicklung erklärt euch Flash, wie man an ein Projekt herangeht und herausfindet was eigentlich zu tun ist. Es geht dabei um Analyse der Anforderungen und die Modellierung sogenannter Use Cases. Die hier vorgestellten Arbeiten sind Grundlage um später Klassen zu finden auf denen dann der Code aufgebaut wird.
|-
![[Tutorial Softwareentwicklung2|Tutorial Softwareentwicklung 2]]
{{Level_3}}
|[[Bild:Tutorial_SWE2.jpg|right]] "Softwareentwicklung2 - Objektorientierte Softwareentwicklung mit UML". 
Im zweiten und umfangreichsten Teil der Serie steht das Thema "Klassen" im Zentrum. Flash erklärt euch wie man aus den Use Cases Klassen ableitet und welche unterschiedlichen Einsatzgebiete Klassen innerhalb der Software haben können.
|-
![[Tutorial Softwareentwicklung3|Tutorial Softwareentwicklung 3]]
{{Level_3}}
|[[Bild:Tutorial_SWE3_Interface.jpg|right|128px]] "Softwareentwicklung3 - Objektorientierte Softwareentwicklung mit UML". 
Im letzten Teil der Serie steht das Thema "Verhalten" im Zentrum. Flash erklärt euch wie die Klassen miteinander in Beziehung gesetzt werden. Außerdem wird nocheinmal auf den RUP als '''iterative''' Vorgehensweise eingegangen.
|-
|}

== Mathematisches ==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial Lineare Algebra]]
{{Level_2}}
|[[Bild:Tutorial_lineare_Algebra_Preview.jpg|right]] "Vektorrechnung". 
In vielen Tutorials tauchen eine Menge Begriffe aus der linearen Algebra und analytischen Geometrie auf. Wer bei Begriffen wie Vektoren, Skalar-Produkt, Vektorkreuzprodukt, etc. ein wenig Auffrischung und Implementationshinweise braucht, ist mit diesem Tutorial von EternalLearner an der richtigen Stelle.
|-
![[Tutorial OpenGL3 Lineare Algebra]]
{{Level_2}}
|[[Bild:Tutorial_lineare_Algebra_Preview.jpg|right]] "Rechnen mit Vektoren und Matrizen". 
Dieses Tutorial von TAK2004 kann als Neuauflage des Tutorials "Lineare Algebra" verstanden werden. Es ist umfangreicher als sein Vorgänger und behandelt auch Matrizen. Zum Schluss werden außerdem ein paar Tipps zur Implementierung gegeben.
|-
![[Tutorial Nachsitzen]]{{Level_1}}
|[[Bild:Tutorial_Nachsitzen_preview.png|right]] "3d-Mathematik". 
Wer die mathematischen Grundlagen wie Sinus, Cosinus und Matrizen aus der Schule schon wieder vergessen oder noch vor sich liegen hat, der kann mit Hilfe dieses Tutorials von Delphic dieses Wissen erlernen bzw. auffrischen.
|-
![[Tutorial Objekt gedreht und dennoch nach vorne bewegt]]
{{Level_2}}
|[[Bild:Tutorial_Objekt_gedreht_und_dennoch_nach_vorne_bewegt_preview.gif|right]] "Objekt gedreht und dennoch nach vorne bewegt". 
SchodMC erklärt in diesem Tutorial wie man ein Objekt drehen und dabei trotzdem vorwärts bewegen kann. Quer fahrende Autos sind zwar praktisch zum Einparken Aber doch eher selten ;-)
|-
![[Tutorial Objekt immer um eigene Achse drehen]]
{{Level_2}}
|[[Bild:Tutorial_Objekt_immer_um_die_eigene_Achse_drehen_preview.gif|right]] "Objekt immer um eigene Achse drehen". 
Wenn ihr euer Objekt nun noch um die eigene Achse drehen wollt, seid ihr mit diesem Tutorial von SchodMC an der richtigen Adresse
|-
![[Tutorial Separating Axis Theorem]]
{{Level_2}}
|[[Bild:SAT_Kollision.jpg|right|128px]] "Separating Axis Theorem" 
Seth erklärt in diesem Tutorial wie man Polygonkollisionen mit Hilfe des ''Seperating Axis Theorem'' erkennen kann.
|-
![[Tutorial Kollision1]]
{{Level_1}}
|[[Bild:Tutorial_Kollision1_Coll2.png|128px|right]] "Kollision 1" 
Reinhard Niehoff fragte uns ob er ein Tutorial über Kollision schreiben könnte. Das konnten wir nicht ablehnen, und so entstand dieses Tutorial in dem grundlegende Kollisionsberechnungen erklärt werden. Weitere sollen folgen.
|-
![[Tutorial Kollision2]]
{{Level_2}}
|[[Bild:Tutorial_Kollision2_Thumb.png|128px|right]] "Kollision 2" 
Beim zweiten Tutorial gehts mehr in die Tiefe und einige Spezialfälle bei Kugel-Polygon-Kollisionen werden erläutert. Mit dabei: Die [[Werkzeugkiste]] mit nützlichen Funktionen.
|-
![[Tutorial Kollision3]]
{{Level_3}}
|[[Bild:Tutorial_Kollision3_Thumb.png|128px|right]] "Kollision 3" 
Beim letzten Tutorial dieser Serie gehts darum, wie man die bisherigen Ansätze in einem Programm unterbringt.
|-
|}

== Grafik und Modellierung ==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial Modellierung eines Low-Poly Menschen Teil 1]]
{{Level_4}}
|[[Bild:Tutorial_Low-Poly-Mensch1_preview.jpg|right]] "Modellierung eines Low-Poly-Menschen". 
Die Modellierung von organischen "Objekten" gehört mit zu den kompliziertesten Aufgaben, die es beim Modelling gibt. Wie man einen Menschen mit aus möglichst wenigen Polygonen mit dem Programm 3D Studio Max erstellen kann wird in diesem Tutorial von Sascha Willems erklärt.
|-
![[Tutorial Modellierung eines Low-Poly Menschen Teil 2]]
{{Level_4}}
|[[Bild:Tutorial_Low-Poly-Mensch2_preview.jpg|right]] "Kleider machen Leute (UVW-Mapping)". 
Nun spendiert Sascha Willems seinem Menschen aus dem 1. Tutorial eine schmucke Uniform, so dass er sich endlich in der Öffentlichkeit blicken lassen kann.
|-
|}

== Skripte ==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial Scripting mit JvInterpreterProgram]]
{{Level_2}}
|[[Bild:Tutorial_JvInterpreter_preview.png|right]] "Skripting mithilfe der Jedi-Code-Library". 
SchodMC erklärt hier wie man mit relativ wenig Aufwand Skripte in eigene Programme integrieren kann.
|-
![[Tutorial Scriptsprachen Teil 1]]
{{Level_5}}
|[[Bild:Tutorial_Skriptsprachen1_preview.gif|right]] "Scriptsprachen Teil 1 - Einführung". 
Für alle die schon immer einmal wissen wollten wie ein Compiler arbeitet ist diese Tutorial-Reihe von Delphic genau das richtige.

Der erste Teil widmet sich der Lexikalischen Analyse und dem Parsen des Quellcodes
|-
![[Tutorial Scriptsprachen Teil 2]]
{{Level_5}}
|[[Bild:Tutorial_Skriptsprachen2_preview.gif|right]] "Scriptsprachen Teil 2 - Virtuelle Computer und Code Erzeugung". 
Für alle die schon immer einmal wissen wollten wie ein Compiler arbeitet ist diese Tutorial-Reihe von Delphic genau das richtige.

Der zweite Teil beschreibt den Bau einer VM und der Codeerzeugung
|-
|}

== Delphi allgemein ==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
! [[Tutorial Debugging]]
{{Level_2}}
| [[Bild:Tutorial Debugging.gif|right]] "Debugger benutzen und andere praktische Tipps" 
In diesem Tutorial werdet von Delphic mit der Nutzung des Delphi-Debuggers eingeführt. Auch werden Wege zur Vermeidung von Fehlern aufgezeigt. Genauso findet Ihr aber auch in diesem Tutorial Hinweise, zu häufig begangenen Fehlern und deren Ursachen.
|-
! [[Tutorial Komponentenentwicklung]]
{{Level_2}}
| [[Bild:Tutorial Komponentenentwicklung.png|right]] "Komponentenentwicklung" 
In diesem Tutorial werdet ihr ein wenig tiefer in die Entwicklung von Komponenten unter Delphi eingeführt. Es wird Grundwissen auf diesem Gebiet vorausgesetzt.
|-
![[Tutorial Multithreading]]
{{Level_3}}
|[[Bild:Tutorial_Multithreading.gif|right]] "Das Prinzip der Dualität". 
Threads sind ein erweitertes Prinzip des bekannten Multitasking und werden innerhalb eines Programmes oft dazu genutzt, verschiedene Aufträge gleichzeitig abzuarbeiten. LossyEx erklärt euch hier deren Nutzung.
|-
! [[Tutorial Software-Synthesizer]]
{{Level_4}}
| [[Bild:Noexist.jpg|right]] "Software-Synthesizer" 
Computerspiele bestehen nicht nur aus Grafik. Dieses Tutorial widmet sich einem ganz anderen Bereich der Spieleprogrammierung: Der Erzeugung von synthetischen Sounds und Musik.
|}

== Rendertechniken ==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
! [[Tutorial Frustum Culling]]
{{Level_1}}
| [[Bild:Tutorial Frustum Culling.jpg|right]] "Frustum Culling" 
Frustum Culling ist eine einfache Möglichkeit die Rendergeschwindigkeit zu erhöhen, da man damit schon vor dem Senden der Daten an die Grafikkarten feststellen kann, welche Objekte sich im Blickfeld des Spielers befinden und welche nicht.
|-
! [[Tutorial Octree]]
{{Level_1}}
| [[Bild:Tutorial Octree preview.jpg|right]] "Octrees" 
Octrees sind eine einfach zu implementierende, aber sehr effiziente Möglichkeit um besonders Outdoor-Szenen abhängig vom Betrachterblickfeld stark zu beschleunigen. In diesem Tutorial zeigt Shadow euch eine komplette Implementation eines Octrees inklusive ausgiebigem Quellcode.
|-
! [[Tutorial Charakteranimation]]
{{Level_4}}
| [[Bild:walk30left.gif|right]] "Charakteranimation" 
Wer menschliche Charaktere oder Tiere lebendig aussehend animieren will, kommt mit herkömmlichen Mitteln wie Translation und Rotation der Modelview-Matrix nicht weiter. In diesem Tutorial erklärt euch glAwesome, wie ihr eure Meshes zum Leben erweckt.
|-
! [[Tutorial Raytracing - Grundlagen I]]
{{Level_4}}
| [[Bild:Tutorial_RaytracingI_thumb.jpg|right]] "Raytracing - Grundlagen I" 
Die Grundzüge des Raytracings Teil 1 - Von den Strahlen bis zur ersten Darstellung von Kugeln und Ebenen
|-
! [[Tutorial Raytracing - Grundlagen II]]
{{Level_4}}
| [[Bild:Tutorial_RaytracingI_thumb.jpg|right]] "Raytracing - Grundlagen II" 
Die Grundzüge des Raytracings Teil 2 - Einfache Basisobjekte, Transformationen und Phong-Lightning
|}

Datei:walk30left.gif

2014-04-16T08:31:14Z

Glawesome: Glawesome lud eine neue Version von „Datei:walk30left.gif“ hoch

Tutorial

2014-04-16T08:16:42Z

Glawesome: /* Rendertechniken */ Bild für Tutorial Charakteranimation hinzugefügt

Auf dieser Seite findet ihr alle Tutorials die DelphiGL.com zu bieten hat. Falls ihr zu einem Thema kein Tutorial findet könnt ihr noch einen Blick auf die [[Techniken und Algorithmen]] werfen. Diese enthalten weitere Artikel zu bestimmten Techniken.

=Hinweise=
Bitte tragt selbst '''keine''' eigenen Tutorials ohne Absprache mit [[Benutzer:Flash (Kevin Fleischer)|Flash]] bzw. [[Benutzer:Phobeus|Phobeus]] hier ein. Tutorials werden prinzipiell vom DGL-Team gegengelesen, ''bevor'' sie veröffentlicht werden.

Wer mit dem Gedanken spielt, ein Tutorial für DGL zu schreiben, sollte sich bereits bei der Themenwahl mit dem DGL-Team absprechen. DGL ist sehr an neuen Tutorials interessiert. Nur sollte man beachten, dass nichts doppelt geschrieben wird, bzw. dass nicht 2 Mann zur selben Zeit das selbe Thema beackern.

==Hinweis für alle Programmieranfänger==
Falls ihr OpenGL nutzen wollt aber noch keinerlei Programmiererfahrung habt, so solltet ihr zuerst eine Programmiersprache lernen.

DGL kann folgende Tutorials empfehlen:

{|{{Prettytable_B1}} width="100%"
!Link
!Sprache
!Beschreibung
|-
|[http://www.delphi-treff.de/tutorials/ Delphitutorials bei www.delphi-treff.de]
|{{Deutsch}}
|Delphi Source der Delphi Treff entstand durch den Zusammenschluss von Delphi-Source und dem Delphi-Treff und wurde mittlerweile wieder in Delphi-Treff umbenannt. Diese Community verfügt über eine ausgezeichnete Sammlung von Tutorials zum Thema "Delphiprogrammierung". Es werden nicht nur die Grundlagen erklärt sondern nahezu alle Bereiche der Programmierung mit Delphi. Außerdem verfügt diese Community über ein Forum welches mit seiner ''Bastelecke'' auch für Anfänger geeignet ist.
|-
|[http://crashkurs.christian-stelzmann.de/ Crashkurs von Christian Stelzmann]
|{{Deutsch}}
|Der Crashkurs von Christian erklärt neben den Grundlagen zur und über die Sprache auch die IDE anhand von zahlreichen einfachen Beispielen, die den Einstieg in Delphi stark vereinfachen und so eine einfache Einführung in die Arbeit mit Delphi bieten.
|-
|}

''Wer sehen möchte was DGLer aus dem hier Gelernten und ihrer Kreativität so machen, findet Beispiele davon in der [[DGL_Projekte]]-Ecke.''

=Tutorials=
{{Hinweis|Alle Tutorials sind der [[:Kategorie:Tutorial]] zugeordnet.}}

<div align="center">
{|{{Prettytable_B1}} width="100%"
!width="15%"|Schwierigkeitsgrad
!Bedeutung
|-
|{{Level_1}}
|Jeder Schritt wird ausführlich erklärt. Absolut Einsteigertauglich.
|-
|{{Level_2}}
|Verständnis der Grundprinzipien wird voraus gesetzt. Die Materie bleibt aber einfach.
|-
|{{Level_3}}
|Ihr wisst um was es geht. Es wird erwartet, dass ihr selbst das Thema weiterdenkt.
|-
|{{Level_4}}
|Das Tutorial bietet euch einen Einstieg. Es wird erwartet, dass ihr euch selbst noch eingehender mit den beschriebenen Techniken befasst. Für Fragen steht unser Forum zur Verfügung.
|-
|{{Level_5}}
|Um das Tutorial zu verstehen werden Kenntnisse auf dem entsprechenden Gebiet vorausgesetzt, welche über Grundwissen hinausgehen. Es wird erwartet, dass ihr euch eingehender mit dem Thema auseinandersetzt und auch andere Quellen lest/gelesen habt. Für Fragen steht unser Forum zur Verfügung.
|}
</div>

== Einsteiger-Tutorials ==
<div align="center">
{{Hinweis|Die Einsteiger-Tutorials wurden auf [[SDL]] umgestellt. Dadurch wurde das Laden von Texturen erleichtert, vor allem aber ermöglicht SDL plattformunabhängig zu programmieren. Ihr benötigt deshalb die ''SDL.pas''. Diese Datei und alle anderen benötigten Dateien findet ihr im '''[[DGLSDK]]'''}}
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial Quickstart]] (VCL)
{{Level_1}}
|[[Bild:Tutorial_Lektion1.gif|right]] "Quickstart: OpenGL & Delphi" 
Für alle, die einen schnellen Einstieg in die OpenGL Programmierung mit Delphi suchen, hat Flash hier einen Einstieg geschaffen. Neben dem erstellen eines eigenen OpenGL-Templates hat er für alle, die Großes mit OpenGL vorhaben, am Ende noch einige Hinweise bereitgestellt.

''In diesem Tutorial wird eine Codevorlage für OpenGL-Projekte geschaffen. Diese basiert allerdings auf Borlands Visual Component Library (VCL) und nicht auf SDL. '''Unabhängig davon beherbergt dieses Tutorial im 2. Teil einige allgemeingültige Hinweise für OpenGL-Anfänger.''' Wer nicht mit SDL arbeitet weil z.B. Plattformunabhängigkeit nicht gewünscht oder durch die Sprache bereits gegeben ist, kann diese Codebasis leicht auf seine Sprache übertragen.''
|-
![[Tutorial Lektion 1]]
{{Level_1}}
|[[Bild:Tutorial_Lektion1.gif|right]] "Nicht zu weit aus dem Fenster lehnen" 
Dieses Tutorial von Magellan ist für alle Neueinsteiger gedacht. Hier werden Grundlagen von "Was ist OpenGL" bis zu "Wie initialisiere ich OpenGL?" besprochen.
|-
![[Tutorial Lektion 2]]
{{Level_1}}
|[[Bild:Tutorial_Lektion2.jpg|right]] "Entdeckung einer neuen Welt" 
Unter dieser Überschrift empfängt euch Phobeus zu eurem ersten OpenGL Tutorial welches sich mit der Anwendung der OpenGL-API befasst.
|-
![[Tutorial Lektion 3]]
{{Level_1}}
|[[Bild:Tutorial_Lektion3.gif|right]] "Eine Welt des Grauens?" 
Hinter diesem Titel verbirgt sich ein Einsteigertutorial zum Thema Matrizen in OpenGL. Wiederum führt euch Phobeus durch den Stoff.
|-
![[Tutorial Lektion 4]]
{{Level_2}}
|[[Bild:Tutorial_Lektion4.png|right]] "Texturen, Tapeten und Ihre Tücken" 
Wie bekomme ich ein Bild auf meine Primitiven? Wer sich diese Frage bei den vorigen Tutorials gestellt hat, der bekommt hier nun von Phobeus die Antworten.
|-
![[Tutorial Lektion 5]]
{{Level_2}}
|[[Bild:Tutorial_Lektion5.jpg|right]] "Artenvielfalten und Ihre Folgen" 
In diesem Tutorial geht Phobeus auf weitere Zeichentechniken und Methoden zur Verbesserung der Performance unter OpenGL ein.
|-
!''Tutorial Lektion 6 ''
|[[Bild:Tutorial_na.jpg|right]] "Dark Engine" 
Dieses Tutorial wurde geplant aber niemals umgesetzt. Heute hätte es auch keine Relevanz mehr, da die Dark Engine nicht gepflegt wurde. Falls ihr ein gutes Einsteigertutorial als Ersatz vorschlagen wollt, könnt ihr dies im Feedback-Forum von DelphiGL.com tun.
|-
![[Tutorial Lektion 7]]
{{Level_2}}
|[[Bild:Tutorial_Lektion7.png|right]] "Verblendet!" 
Wenn man halbdurchsichtige Fensterscheiben, Lightmaps oder etwas ähnliches in sein Projekt einbauen will, dann kommt man um Blending nicht herum. Wie man das ganze Nutzen kann ist in diesem Tutorial von Phobeus erklärt.
|-
![[Tutorial Lektion 8]]
{{Level_2}}
|[[Bild:Tutorial_Lektion8.gif|right]] "Das Wesen von hell und dunkel - Licht" 
Ohne Beleuchtung sieht selbst jede 3D-Umgebung platt aus. In diesem Tutorial wird primär der richtige Gebrauch des OpenGL-Lichtes beschrieben. Darüberhinaus wird noch die Berechnung von Normalen erklärt.
|-
![[Tutorial 2D]]
{{Level_2}}
|[[Bild:Tutorial_2D.jpg|right]] "2D mit OpenGL" 
OpenGL ist zwar primär eine 3D-API, eignet sich aber, nicht zuletzt dank seiner leistungsstarken Hardwarebeschleunigung und der damit verbundenen Features, auch sehr gut für reine 2D-Anwendungen. Dieses Tutorial von Sascha Willems geht sehr ausführlich auf die Nutzung von OpenGL für 2D-Anwendungen ein.
|-
![[Tutorial Matrix2]]
{{Level_1}}
|[[Bild:Tutorial_Matrix2.png|right]] "Matrix2 - Matrizen und Matrixmanipulationen" 
Das Thema Matrizen stellt OpenGL-Einsteiger regelmäßig vor "unlösbare" Aufgaben: 
''Wieso dreht sich der Würfel so komisch, und nicht um sich selbst?'' 
''Wieso verschiebt OpenGL die Kugel denn dahin, und nicht dorthin?'' 
Dieses Tutorial von Flash befasst sich mit den 3 Matrixtypen, die es in OpenGL gibt und erklärt was die Befehle '''glScale, glRotate und glTranslate''' wirklich machen.
|-
|}
</div>

== Grundlagen-Tutorials ==
<div align="center">
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial Abseits eckiger Welten]]
{{Level_2}}
|[[Bild:Tutorial_Abseits_eckiger_Welten.gif|right]] "Abseits eckiger Welten" 
3D-Welten bestehen seit eh und je aus Dreiecken, was sie oft recht eckig erscheinen lässt. In diesem Tutorial lernt ihr allerdings wie man mit Hilfe von Evaluatoren in OpenGL auch Rundungen erzeugen kann.
|-
![[Tutorial Renderpass]]
{{Level_1}}
|[[Bild:Tutorial_Renderpass.jpg|right]] "Renderpass - Die Welt daneben" 
OpenGL bietet nicht nur die Möglichkeit seine Szene direkt auf den Bildschirm zu rendern, sondern auch diese in eine Textur zu rendern um diese dann auf ein Objekt zu kleben. Dadurch ergeben sich diverse neue Möglichkeiten, wie z.B. Spiegel, Portale oder nachträgliche Manipulation der Textur. Wie ihr eure Szene in eine Textur bekommt, erfahrt ihr hier.
|-
![[Tutorial Selection]]
{{Level_2}}
|[[Bild:Tutorial_Selection.gif|right]] "Objectselektion A" 
Die Selektion von Objekten braucht man spätestens dann, wenn man ein komfortable Interaktion mit der Spielwelt erstellen will. Mit diesem Tutorial von DCW_MrT ist die Thematik kein Problem mehr.
|-
! [[Tutorial Objektselektion]]
{{Level_2}}
| [[Bild:Tutorial_Selection_tut03.jpg|right]] "Objektselektion B" 
Wie simpel der Objektselektionsmodus von OpenGL zu benutzen ist, wird in diesem Tutorial von Sascha Willems vermittelt. Dazu gibt es den Source-Code und eine fertig kompilierte Anwendung.
|-
! [[Tutorial ColorPicking Shader]]
{{Level_2}}
| [[Bild:Tutorial_ColorPicking_Screenie.png|right]] "Color Picking Implementation mit Shadern" 
Die einfache Umsetzung von Color Picking ohne [[Shader]] enthält einige Nachteile die bei einer entsprechenden Umsetzung mit Shadern vermieden werden können. Dieses Tutorial zeigt eine shaderbasierte Methode ColorPicking so einzusetzen, dass es performant auch in größeren Szenen genutzt werden kann. Durch die Nutzung von Shadern und dem Fokus auf Optimierung des Selektionsvorganges sowie der Beachtung von Sonderfällen richtet sich dieses Tutorial an erfahrenere OpenGL Programmierer.
|-
![[Tutorial TexFilter]]
{{Level_1}}
|[[Bild:Tutorial_TexFilter.jpg|right]] "Texturfilterung - Texturen-Feintuning" 
Texturen sind seit langem ein wichtiger Bestandteil im Bereich der Echtzeitgrafik. OpenGL bietet auf diesem Gebiet auch diverse Möglichkeiten Texturen auch filtern zu lassen. Welche das sind und wie sie sich auswirken, könnt ihr in diesem Tutorial von Delphic nachlesen.
|-
![[Tutorial Kamera1]]
{{Level_2}}
|[[Bild:Tutorial_Kamera1.gif|right]] "Dreht sich das Universum um uns? und andere philosophische Fragen" 
In diesem Tutorial von Delphic geht es um die Kamera. Wie eine Kameraklasse gebaut sein könnte und was sie macht wird hier erklärt.
|-
|}
</div>

== Effekte ==
<div align="center">
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial Nebel]]
{{Level_2}}
|[[Bild:Tutorial_Nebel.jpg|right]] "DGL Fogging Tutorial". 
Erstaunlich einfach lässt sich mit OpenGL Nebel darstellen. Wie einfach, zeigt euch Lithander in diesem Tutorial.
|-
![[Tutorial Partikel1]]
{{Level_2}}
|[[Bild:Tutorial_Partikel1.gif|right]] "Partikel-Tutorial I". 
Eine Partikel-Engine sollte in (fast) jeder Engine enthalten sein. Anhand dieses Tutorials von Lithander könnt ihr den Grundstein dazu legen.
|-
![[Tutorial BumpMap]]
{{Level_3}}
|[[Bild:Tutorial_BumpMap.png|right]] "Bumpmapping - Plastisches 2D". 
Bumpmapping ist eine immer stärker genutzte Technik, um polygonarme Oberflächen ohne Tesselation mit vorgegaukelten Details - abhängig vom Lichteinfall - zu versehen. In diesem Tutorial zeigt euch HomerS, wie man Bumpmapping über die NVIDIA-spezifischen Combiner realisiert.
|-
![[Tutorial MultiTexturing]]
{{Level_2}}
|[[Bild:Multitex05.jpg|right]] "Multitexturing". 
Wie man mehrere Texturen auf ein Polygon bringen kann, erklärt auch Sascha Willems in diesem Tutorial zum Thema Multitexturing. Multitexturing ist seit OpenGL1.3 Teil des GL-Kerns und kann für z.B. für Lightmapping bzw. Detailmapping verwendet werden.
|-
![[Tutorial StencilSpiegel]]
{{Level_3}}
|[[Bild:Tutorial_StencilSpiegel.jpg|right]] "Spiegelungen mit dem Stencil-Buffer". 
Eine Echtzeit-Spiegelung ist einer der schönsten Effekte einer 3D-Welt und trägt viel zum Realismus bei. Eine Möglichkeit Spiegelungen über den Stencilpuffer zu realisieren, wird in diesem Tutorial von Sascha Willems erklärt.
|-
![[Tutorial StereoSehen]]
{{Level_3}}
|[[Bild:Tutorial_StereoSehen.gif|right]]Auch wenn moderne Grafikkarten durch eine immer besser werdende Darstellung dem Benutzer versuchen das Betreten einer virtuellen 3D-Welt vorzugaukeln, so schafft es doch auch das beste Doom3-Monster nur bis zur Glasröhre zu erschrecken, rutscht dann aber quietschend davon ab. Was also tun, wenn man einen Schritt weiter gehen und dem Anwender wirkliches 3D bieten möchte? Wer eine 3D-Brille hat, wird mit diesem Tutorial von Delphic eine Möglichkeit finden, die dritte Dimension am Computer zur erschließen.
|-
![[Tutorial Alphamasking]]
{{Level_2}}
|[[Bild:Tutorial_Alphamasking_tut04.jpg|right]]In diesem kleinen aber feinen Tutorial erklärt Sascha Willems, wie man Alphamasking dazu verwenden kann, eine Szene optisch aufzuwerten und gleichzeitig Performance zu sparen.
|-
![[Tutorial Wassereffekt]]
{{Level_2}}
|[[Bild:Wassertutorial-scrshot-preview.jpg|right]]In diesem Tutorial erklärt Lord Horazont wie man eine Wasserebene mit Brechungen mit und ohne Shader erzeugen kann.
|-
|}
</div>

==Extensions==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial Cubemap]]
{{Level_3}}
|[[Bild:Tutorial_Cubemap_mini.jpg|right]] "GL_ARB_Texture_Cubemap". 
In diesem Tutorial erklärt Sascha Willems die Grundfunktionen der '''GL_ARB_Texture_Cubemap'''-Extension und zeigt auch weiterführende Techniken auf.
|-
![[Tutorial Vertexbufferobject]]
{{Level_3}}
|[[Bild:Tutorial Vertexbufferobject preview.jpg|right]] "GL_ARB_Vertex_Buffer_Object". 
Diese Extension führte '''VBO'''s ein. Wie man mit damit Vertexdaten schnell im Grafikkarten- und Hauptspeicher ablegt und darauf zugreift, erklärt Sascha Willems in diesem Tutorial.
|-
![[Tutorial Vertexprogramme]]
{{Level_3}}
|[[Bild:Tutorial_VP_preview.jpg|right]] "GL_ARB_Vertex_Program". 
In diesem umfangreichen Tutorial werden alle wichtigen Bereiche der Programmierung mit der GL_ARB_Vertex_Program-Extension abgedeckt. Man kann es als umfassende deutsche Referenz zu diesem Thema sehen, da auch alle wichtigen Funktionen aufgelistet werden und es auch sonst an nichts fehlt.
|-
![[Tutorial NVOcclusionQuery]]
{{Level_3}}
|[[Bild:Tutorial_NVO_preview.jpg|right]] "NV_Occlusion_Query". 
Lard Middendorf geht in diesem Tutorial auf die Verwendung der NV_Occlusion_Query-Extension ein.
|-
![[Tutorial Pixelbuffer]]
{{Level_3}}
|[[Bild:Tutorial_Pixelbuffer_preview.jpg|right]] "WGL_ARB_Pixel_Buffer". 
Sascha Willems erklärt hier leicht verständlich den Umgang mit der Pixelbuffer-Extension. Als Additum wird auch noch auf die Nutzung dieser Extension für Shadowmapping eingegangen.
|-
![[Tutorial_Framebufferobject]]
{{Level_3}}
|[[Bild:Tutorial_Framebufferobject_Preview.jpg|right]] "GL_EXT_FRAMEBUFFER_OBJECT". 
Deathball erklärt in diesem Tutorial wie man Framebufferobjekte erstellt und diese zum Offscreenrendern benutzt.
|-
|}

== Shader ==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial glsl|Tutorial glSlang]]
{{Level_4}}
|[[Bild:Tutorial_glsl1.png|right]] "Einführung in GLSL". 
Nach langem Ringen und Handeln hat es das ARB letztendlich doch geschafft, eine einheitliche Shaderhochsprache für OpenGL zu veröffentlichen, nämlich ''glSlang''. Mit glSlang können nun auch unter OpenGL Vertex- und Fragment-Shader in einer lesbaren, C-ähnlichen Hochsprache geschrieben werden, was deren Entwicklung stark vereinfacht. Diese Einführung von Sascha Willems ist weniger ein Tutorial, als ein kompletter Überblick über glSlang. Hier erfährt der Leser nicht nur etwas über die Benutzung von Shadern im Programm, sondern auch alles über die Sprachelemente, inklusive diverser Beispiele.
|-
![[Tutorial glsl2|Tutorial glSlang 2]]
{{Level_4}}
|[[Bild:Tutorial_na.jpg|right]] "GLSL-Ergänzungen und Beispiele". 
Dieses Tutorial von La_Boda ist eine direkte Fortsetzung des GLSL-Tutorials. Es behandelt verstärkt die Praxis und liefert anhand von einigen Beispielen eine bessere Sicht auf die bereits gelernte Theorie.
|-
|}

== KI ==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial pathfinding|Tutorial Pathfinding]]
{{Level_2}}
|[[Bild:Tutorial_pathfinding.png|right]] "Pathfinding 1". 
In diesem Tutorial zeigt euch Flo wie man recht simpel eine Wegfindungsroutine implementiert. Besonders wenn man sowas ohne großen Lernaufwand in sein Spiel einbinden möchte, sollte man einen Blick riskieren.
|-
![[Tutorial pathfinding2|Tutorial Pathfinding 2]]
{{Level_3}}
|[[Bild:Tutorial_pathfinding2.png|right]] "Pathfinding 2". 
Gerade bei aktuelleren Programmen reicht es meist nicht aus, wenn man seine Einheiten nur in 8 Himmelsrichtungen bewegen kann. Frase stellt in diesem Tutorial vor, wie man eine Wegfindungsroutine implementieren kann, wie diese in einem heutigen RTS vorkommen kann.
|-
|}

== Terrain und Landschaften ==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial Terrain1]]
{{Level_4}}
|[[Bild:Tutorial_Terrain1.gif|right]] "Außenlandschaften mit System - Heightmaps". 
Anhand der Graustufenwerte einer Bitmap-Datei kann man relativ einfach eine imposante Landschaft erstellen. Wie das ganze funktioniert erklärt euch Delphic in diesem Tutorial. Außerdem wird noch die Implementation von Skyboxen erklärt.
|-
![[Tutorial Terrain2|Tutorial Terrain 2]]
{{Level_4}}
|[[Bild:Tutorial_Terrain2.gif|right]] "Heightmap-Texturen". 
Da das Terrain aus dem vorigen Tutorial noch recht eintönig grau aussieht und das natürlich geändert werden soll, erklärt euch Delphic, wie man schmucke Schatten und Texturen für die Heightmap generieren kann.
|-
![[Tutorial Terrain3|Tutorial Terrain 3]]
{{Level_5}}
|[[Bild:Tutorial_Terrain3.gif|right]] "Terrain im Detail". 
Da größere Landschaften aufgrund der hohen Polygonanzahl sehr aufwändig zu rendern sind erklärt euch Delphic hier, wie man entfernte Dreiecke "zusammenlegen" kann, um Rechenleistung zu sparen.
|-
![[Tutorial Skyboxen]]
{{Level_2}}
|[[Bild:Tutorial_Skybox_Vorschau.jpg|right]] "Skyboxen". 
In diesem Tutorial erklärt Sascha Willems kurz und bündig den Umgang mit Skyboxen, mit denen man Landschaften schnell sehr stark optisch aufwerten kann. Es wird sowohl auf die Erstellung der Skybox-Texturen mit dem Programm Terragen als auch die Implementation der Skybox in OpenGL eingegangen.
|-
|}

== Spieletutorials und Softwareentwicklung==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial Bomberman1|Tutorial Bomberman 1]]
{{Level_3}}
|[[Bild:Tutorial_Bomberman1.jpg|right]] "Bomberman1 - Codebasis und Editor". 
Im ersten Teil dieser kleinen Tutorialserie zum Thema Spieleprogrammierung kümmern wir uns neben der Erstellung unseres Basiscodes auch um einen fertigen Editor. Nach der Durcharbeitung dieses Tutorials von Sascha Willems sollte der Leser alle Grundprinzipien zur Programmierung eines Spiels verstanden haben.
|-
![[Tutorial Bomberman2|Tutorial Bomberman 2]]
{{Level_3}}
|[[Bild:Tutorial_Bomberman2.jpg|right]] "Bomberman2 - Der 3D-Bombermanklon (Grundversion)". 
Im zweiten Teil gehts ans Eingemachte, nämlich einen fertigen Bombermanklon. In Sascha Willems Tutorial werdet ihr zusätzlich zu den bereits erworbenen Prinzipien diverse Techniken die in so ziemlich jedem Spiel Verwendung finden erlernen.
|-
![[Tutorial Softwareentwicklung1|Tutorial Softwareentwicklung 1]]
{{Level_3}}
|[[Bild:Tutorial_SWE1.jpg|right]] "Softwareentwicklung1 - Objektorientierte Softwareentwicklung mit UML". 
Im ersten Teil dieser Tutorialserie zum Thema Softwareentwicklung erklärt euch Flash, wie man an ein Projekt herangeht und herausfindet was eigentlich zu tun ist. Es geht dabei um Analyse der Anforderungen und die Modellierung sogenannter Use Cases. Die hier vorgestellten Arbeiten sind Grundlage um später Klassen zu finden auf denen dann der Code aufgebaut wird.
|-
![[Tutorial Softwareentwicklung2|Tutorial Softwareentwicklung 2]]
{{Level_3}}
|[[Bild:Tutorial_SWE2.jpg|right]] "Softwareentwicklung2 - Objektorientierte Softwareentwicklung mit UML". 
Im zweiten und umfangreichsten Teil der Serie steht das Thema "Klassen" im Zentrum. Flash erklärt euch wie man aus den Use Cases Klassen ableitet und welche unterschiedlichen Einsatzgebiete Klassen innerhalb der Software haben können.
|-
![[Tutorial Softwareentwicklung3|Tutorial Softwareentwicklung 3]]
{{Level_3}}
|[[Bild:Tutorial_SWE3_Interface.jpg|right|128px]] "Softwareentwicklung3 - Objektorientierte Softwareentwicklung mit UML". 
Im letzten Teil der Serie steht das Thema "Verhalten" im Zentrum. Flash erklärt euch wie die Klassen miteinander in Beziehung gesetzt werden. Außerdem wird nocheinmal auf den RUP als '''iterative''' Vorgehensweise eingegangen.
|-
|}

== Mathematisches ==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial Lineare Algebra]]
{{Level_2}}
|[[Bild:Tutorial_lineare_Algebra_Preview.jpg|right]] "Vektorrechnung". 
In vielen Tutorials tauchen eine Menge Begriffe aus der linearen Algebra und analytischen Geometrie auf. Wer bei Begriffen wie Vektoren, Skalar-Produkt, Vektorkreuzprodukt, etc. ein wenig Auffrischung und Implementationshinweise braucht, ist mit diesem Tutorial von EternalLearner an der richtigen Stelle.
|-
![[Tutorial Nachsitzen]]{{Level_1}}
|[[Bild:Tutorial_Nachsitzen_preview.png|right]] "3d-Mathematik". 
Wer die mathematischen Grundlagen wie Sinus, Cosinus und Matrizen aus der Schule schon wieder vergessen oder noch vor sich liegen hat, der kann mit Hilfe dieses Tutorials von Delphic dieses Wissen erlernen bzw. auffrischen.
|-
![[Tutorial Objekt gedreht und dennoch nach vorne bewegt]]
{{Level_2}}
|[[Bild:Tutorial_Objekt_gedreht_und_dennoch_nach_vorne_bewegt_preview.gif|right]] "Objekt gedreht und dennoch nach vorne bewegt". 
SchodMC erklärt in diesem Tutorial wie man ein Objekt drehen und dabei trotzdem vorwärts bewegen kann. Quer fahrende Autos sind zwar praktisch zum Einparken Aber doch eher selten ;-)
|-
![[Tutorial Objekt immer um eigene Achse drehen]]
{{Level_2}}
|[[Bild:Tutorial_Objekt_immer_um_die_eigene_Achse_drehen_preview.gif|right]] "Objekt immer um eigene Achse drehen". 
Wenn ihr euer Objekt nun noch um die eigene Achse drehen wollt, seid ihr mit diesem Tutorial von SchodMC an der richtigen Adresse
|-
![[Tutorial Separating Axis Theorem]]
{{Level_2}}
|[[Bild:SAT_Kollision.jpg|right|128px]] "Separating Axis Theorem" 
Seth erklärt in diesem Tutorial wie man Polygonkollisionen mit Hilfe des ''Seperating Axis Theorem'' erkennen kann.
|-
![[Tutorial Kollision1]]
{{Level_1}}
|[[Bild:Tutorial_Kollision1_Coll2.png|128px|right]] "Kollision 1" 
Reinhard Niehoff fragte uns ob er ein Tutorial über Kollision schreiben könnte. Das konnten wir nicht ablehnen, und so entstand dieses Tutorial in dem grundlegende Kollisionsberechnungen erklärt werden. Weitere sollen folgen.
|-
![[Tutorial Kollision2]]
{{Level_2}}
|[[Bild:Tutorial_Kollision2_Thumb.png|128px|right]] "Kollision 2" 
Beim zweiten Tutorial gehts mehr in die Tiefe und einige Spezialfälle bei Kugel-Polygon-Kollisionen werden erläutert. Mit dabei: Die [[Werkzeugkiste]] mit nützlichen Funktionen.
|-
![[Tutorial Kollision3]]
{{Level_3}}
|[[Bild:Tutorial_Kollision3_Thumb.png|128px|right]] "Kollision 3" 
Beim letzten Tutorial dieser Serie gehts darum, wie man die bisherigen Ansätze in einem Programm unterbringt.
|-
|}

== Grafik und Modellierung ==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial Modellierung eines Low-Poly Menschen Teil 1]]
{{Level_4}}
|[[Bild:Tutorial_Low-Poly-Mensch1_preview.jpg|right]] "Modellierung eines Low-Poly-Menschen". 
Die Modellierung von organischen "Objekten" gehört mit zu den kompliziertesten Aufgaben, die es beim Modelling gibt. Wie man einen Menschen mit aus möglichst wenigen Polygonen mit dem Programm 3D Studio Max erstellen kann wird in diesem Tutorial von Sascha Willems erklärt.
|-
![[Tutorial Modellierung eines Low-Poly Menschen Teil 2]]
{{Level_4}}
|[[Bild:Tutorial_Low-Poly-Mensch2_preview.jpg|right]] "Kleider machen Leute (UVW-Mapping)". 
Nun spendiert Sascha Willems seinem Menschen aus dem 1. Tutorial eine schmucke Uniform, so dass er sich endlich in der Öffentlichkeit blicken lassen kann.
|-
|}

== Skripte ==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial Scripting mit JvInterpreterProgram]]
{{Level_2}}
|[[Bild:Tutorial_JvInterpreter_preview.png|right]] "Skripting mithilfe der Jedi-Code-Library". 
SchodMC erklärt hier wie man mit relativ wenig Aufwand Skripte in eigene Programme integrieren kann.
|-
![[Tutorial Scriptsprachen Teil 1]]
{{Level_5}}
|[[Bild:Tutorial_Skriptsprachen1_preview.gif|right]] "Scriptsprachen Teil 1 - Einführung". 
Für alle die schon immer einmal wissen wollten wie ein Compiler arbeitet ist diese Tutorial-Reihe von Delphic genau das richtige.

Der erste Teil widmet sich der Lexikalischen Analyse und dem Parsen des Quellcodes
|-
![[Tutorial Scriptsprachen Teil 2]]
{{Level_5}}
|[[Bild:Tutorial_Skriptsprachen2_preview.gif|right]] "Scriptsprachen Teil 2 - Virtuelle Computer und Code Erzeugung". 
Für alle die schon immer einmal wissen wollten wie ein Compiler arbeitet ist diese Tutorial-Reihe von Delphic genau das richtige.

Der zweite Teil beschreibt den Bau einer VM und der Codeerzeugung
|-
|}

== Delphi allgemein ==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
! [[Tutorial Debugging]]
{{Level_2}}
| [[Bild:Tutorial Debugging.gif|right]] "Debugger benutzen und andere praktische Tipps" 
In diesem Tutorial werdet von Delphic mit der Nutzung des Delphi-Debuggers eingeführt. Auch werden Wege zur Vermeidung von Fehlern aufgezeigt. Genauso findet Ihr aber auch in diesem Tutorial Hinweise, zu häufig begangenen Fehlern und deren Ursachen.
|-
! [[Tutorial Komponentenentwicklung]]
{{Level_2}}
| [[Bild:Tutorial Komponentenentwicklung.png|right]] "Komponentenentwicklung" 
In diesem Tutorial werdet ihr ein wenig tiefer in die Entwicklung von Komponenten unter Delphi eingeführt. Es wird Grundwissen auf diesem Gebiet vorausgesetzt.
|-
![[Tutorial Multithreading]]
{{Level_3}}
|[[Bild:Tutorial_Multithreading.gif|right]] "Das Prinzip der Dualität". 
Threads sind ein erweitertes Prinzip des bekannten Multitasking und werden innerhalb eines Programmes oft dazu genutzt, verschiedene Aufträge gleichzeitig abzuarbeiten. LossyEx erklärt euch hier deren Nutzung.
|-
! [[Tutorial Software-Synthesizer]]
{{Level_4}}
| [[Bild:Noexist.jpg|right]] "Software-Synthesizer" 
Computerspiele bestehen nicht nur aus Grafik. Dieses Tutorial widmet sich einem ganz anderen Bereich der Spieleprogrammierung: Der Erzeugung von synthetischen Sounds und Musik.
|}

== SDL ==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial SDL Einstieg]]
{{Level_2}}
|[[Bild:Tutorial_Lektion1.gif|right]] "SDL-Einsteiger-Tutorial" 
Crossplattform-Programmierung ist das Zauberwort, welches in den letzten Jahren - dank verstärkter Präsenz von Linux - immer wieder in den Programmierforen des Internets auftaucht. Für Grafikprogrammier ist [[SDL]] hier das Mittel der Wahl. Bekannte Titel wie "Quake III" und "Civilisation - Call to Power" bauen bereits auf diese Bibiothek für ihre Linux-Ports. Phobeus zeigt euch in diesem ersten SDL-Tutorial was SDL ist und wie man es benutzt.
|-
![[Tutorial SDL_RWops]]
{{Level_2}}
| [[Bild:Noexist.jpg|right]] "SDL_RWops-Tutorial" 
SDL benutzt für den Dateizugriff SDL_RWops. [[Benutzer:Lord Horazont|Lord Horazont]] zeigt euch in diesen Tutorial wie man diese benutzt und auch komfortabler gestaltet.
|}

== Rendertechniken ==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
! [[Tutorial Frustum Culling]]
{{Level_1}}
| [[Bild:Tutorial Frustum Culling.jpg|right]] "Frustum Culling" 
Frustum Culling ist eine einfache Möglichkeit die Rendergeschwindigkeit zu erhöhen, da man damit schon vor dem Senden der Daten an die Grafikkarten feststellen kann, welche Objekte sich im Blickfeld des Spielers befinden und welche nicht.
|-
! [[Tutorial Octree]]
{{Level_1}}
| [[Bild:Tutorial Octree preview.jpg|right]] "Octrees" 
Octrees sind eine einfach zu implementierende, aber sehr effiziente Möglichkeit um besonders Outdoor-Szenen abhängig vom Betrachterblickfeld stark zu beschleunigen. In diesem Tutorial zeigt Shadow euch eine komplette Implementation eines Octrees inklusive ausgiebigem Quellcode.
|-
! [[Tutorial Charakteranimation]]
{{Level_4}}
| [[Bild:walk30left.gif|right]] "Charakteranimation" 
Wer menschliche Charaktere oder Tiere lebendig aussehend animieren will, kommt mit herkömmlichen Mitteln wie Translation und Rotation der Modelview-Matrix nicht weiter. In diesem Tutorial erklärt euch glAwesome, wie ihr eure Meshes zum Leben erweckt.
|}

== Raytracing ==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
! [[Tutorial Raytracing - Grundlagen I]]
{{Level_4}}
| [[Bild:Tutorial_RaytracingI_thumb.jpg|right]] "Raytracing - Grundlagen I" 
Die Grundzüge des Raytracings Teil 1 - Von den Strahlen bis zur ersten Darstellung von Kugeln und Ebenen
|-
! [[Tutorial Raytracing - Grundlagen II]]
{{Level_4}}
| [[Bild:Tutorial_RaytracingI_thumb.jpg|right]] "Raytracing - Grundlagen II" 
Die Grundzüge des Raytracings Teil 2 - Einfache Basisobjekte, Transformationen und Phong-Lightning
|}

== Sonstiges ==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
! [[Tutorial GLScene]]
{{Level_1}}
| [[Bild:Tutorial GLScene preview.jpg|right]] "Einführung in GLScene" 
GLScene ist eine zu erstaunlicher Größe angewachsene Komponentensammlung, die quasi einen OpenGL-Wrapper darstellt und euch dank Delphis VCL dadurch recht einfach OpenGL-Programme erstellen lässt. LaBoda gibt euch zu dieser Komponentensammlung in diesem Tutorial deshalb eine kleine Einführung.
|-
! [[Tutorial WebGL]]
{{Level_4}}
| [[Datei:webgl-sporeviewer.jpg|128px|right]] "WebGL" 
WebGL ist der neue Standard für OpenGL im Browser. Der Standard ermöglicht es hardwarebeschleunigte 3D-Grafik mit Shadern im Browser darzustellen, ohne dabei auf spezielle Plugins angewiesen zu sein. [[Benutzer:Coolcat|Coolcat]] stellt euch in diesem Tutorial die Besonderheiten dieses JavaScript-Bindings für OpenGL ES 2.0 gegenüber anderen OpenGL-Anwendungen vor.
|}

Datei:walk30left.gif

2014-04-16T08:14:45Z

Glawesome:

Tutorial Allgemeines

2014-04-12T10:40:34Z

Glawesome: Die Seite wurde neu angelegt: „Auf dieser Seite sind alle Tutorials von DGL aufgelistet, die nicht direkt etwas mit OpenGL zu tun haben. Dennoch sind die Inhalte für die meisten OpenGL-Entw…“

Auf dieser Seite sind alle Tutorials von DGL aufgelistet, die nicht direkt etwas mit OpenGL zu tun haben. Dennoch sind die Inhalte für die meisten OpenGL-Entwickler durchaus relevant. Wer etwas über OpenGL selbst lernen will, sollte sich [[Tutorial GL3+]] ansehen. Außerdem gibt es noch eine ganze Menge lesenswerte aber veraltete Tutorials im Artikel [[Tutorial deprecated OpenGL]].

=Tutorials=
{{Hinweis|Alle Tutorials sind der [[:Kategorie:Tutorial]] zugeordnet.}}

<div align="center">
{|{{Prettytable_B1}} width="100%"
!width="15%"|Schwierigkeitsgrad
!Bedeutung
|-
|{{Level_1}}
|Jeder Schritt wird ausführlich erklärt. Absolut Einsteigertauglich.
|-
|{{Level_2}}
|Verständnis der Grundprinzipien wird voraus gesetzt. Die Materie bleibt aber einfach.
|-
|{{Level_3}}
|Ihr wisst um was es geht. Es wird erwartet, dass ihr selbst das Thema weiterdenkt.
|-
|{{Level_4}}
|Das Tutorial bietet euch einen Einstieg. Es wird erwartet, dass ihr euch selbst noch eingehender mit den beschriebenen Techniken befasst. Für Fragen steht unser Forum zur Verfügung.
|-
|{{Level_5}}
|Um das Tutorial zu verstehen werden Kenntnisse auf dem entsprechenden Gebiet vorausgesetzt, welche über Grundwissen hinausgehen. Es wird erwartet, dass ihr euch eingehender mit dem Thema auseinandersetzt und auch andere Quellen lest/gelesen habt. Für Fragen steht unser Forum zur Verfügung.
|}
</div>

== KI ==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial pathfinding|Tutorial Pathfinding]]
{{Level_2}}
|[[Bild:Tutorial_pathfinding.png|right]] "Pathfinding 1". 
In diesem Tutorial zeigt euch Flo wie man recht simpel eine Wegfindungsroutine implementiert. Besonders wenn man sowas ohne großen Lernaufwand in sein Spiel einbinden möchte, sollte man einen Blick riskieren.
|-
![[Tutorial pathfinding2|Tutorial Pathfinding 2]]
{{Level_3}}
|[[Bild:Tutorial_pathfinding2.png|right]] "Pathfinding 2". 
Gerade bei aktuelleren Programmen reicht es meist nicht aus, wenn man seine Einheiten nur in 8 Himmelsrichtungen bewegen kann. Frase stellt in diesem Tutorial vor, wie man eine Wegfindungsroutine implementieren kann, wie diese in einem heutigen RTS vorkommen kann.
|-
|}

== Spieletutorials und Softwareentwicklung==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial Bomberman1|Tutorial Bomberman 1]]
{{Level_3}}
|[[Bild:Tutorial_Bomberman1.jpg|right]] "Bomberman1 - Codebasis und Editor". 
Im ersten Teil dieser kleinen Tutorialserie zum Thema Spieleprogrammierung kümmern wir uns neben der Erstellung unseres Basiscodes auch um einen fertigen Editor. Nach der Durcharbeitung dieses Tutorials von Sascha Willems sollte der Leser alle Grundprinzipien zur Programmierung eines Spiels verstanden haben.
|-
![[Tutorial Bomberman2|Tutorial Bomberman 2]]
{{Level_3}}
|[[Bild:Tutorial_Bomberman2.jpg|right]] "Bomberman2 - Der 3D-Bombermanklon (Grundversion)". 
Im zweiten Teil gehts ans Eingemachte, nämlich einen fertigen Bombermanklon. In Sascha Willems Tutorial werdet ihr zusätzlich zu den bereits erworbenen Prinzipien diverse Techniken die in so ziemlich jedem Spiel Verwendung finden erlernen.
|-
![[Tutorial Softwareentwicklung1|Tutorial Softwareentwicklung 1]]
{{Level_3}}
|[[Bild:Tutorial_SWE1.jpg|right]] "Softwareentwicklung1 - Objektorientierte Softwareentwicklung mit UML". 
Im ersten Teil dieser Tutorialserie zum Thema Softwareentwicklung erklärt euch Flash, wie man an ein Projekt herangeht und herausfindet was eigentlich zu tun ist. Es geht dabei um Analyse der Anforderungen und die Modellierung sogenannter Use Cases. Die hier vorgestellten Arbeiten sind Grundlage um später Klassen zu finden auf denen dann der Code aufgebaut wird.
|-
![[Tutorial Softwareentwicklung2|Tutorial Softwareentwicklung 2]]
{{Level_3}}
|[[Bild:Tutorial_SWE2.jpg|right]] "Softwareentwicklung2 - Objektorientierte Softwareentwicklung mit UML". 
Im zweiten und umfangreichsten Teil der Serie steht das Thema "Klassen" im Zentrum. Flash erklärt euch wie man aus den Use Cases Klassen ableitet und welche unterschiedlichen Einsatzgebiete Klassen innerhalb der Software haben können.
|-
![[Tutorial Softwareentwicklung3|Tutorial Softwareentwicklung 3]]
{{Level_3}}
|[[Bild:Tutorial_SWE3_Interface.jpg|right|128px]] "Softwareentwicklung3 - Objektorientierte Softwareentwicklung mit UML". 
Im letzten Teil der Serie steht das Thema "Verhalten" im Zentrum. Flash erklärt euch wie die Klassen miteinander in Beziehung gesetzt werden. Außerdem wird nocheinmal auf den RUP als '''iterative''' Vorgehensweise eingegangen.
|-
|}

== Mathematisches ==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial Lineare Algebra]]
{{Level_2}}
|[[Bild:Tutorial_lineare_Algebra_Preview.jpg|right]] "Vektorrechnung". 
In vielen Tutorials tauchen eine Menge Begriffe aus der linearen Algebra und analytischen Geometrie auf. Wer bei Begriffen wie Vektoren, Skalar-Produkt, Vektorkreuzprodukt, etc. ein wenig Auffrischung und Implementationshinweise braucht, ist mit diesem Tutorial von EternalLearner an der richtigen Stelle.
|-
![[Tutorial OpenGL3 Lineare Algebra]]
{{Level_2}}
|[[Bild:Tutorial_lineare_Algebra_Preview.jpg|right]] "Rechnen mit Vektoren und Matrizen". 
Dieses Tutorial von TAK2004 kann als Neuauflage des Tutorials "Lineare Algebra" verstanden werden. Es ist umfangreicher als sein Vorgänger und behandelt auch Matrizen. Zum Schluss werden außerdem ein paar Tipps zur Implementierung gegeben.
|-
![[Tutorial Nachsitzen]]{{Level_1}}
|[[Bild:Tutorial_Nachsitzen_preview.png|right]] "3d-Mathematik". 
Wer die mathematischen Grundlagen wie Sinus, Cosinus und Matrizen aus der Schule schon wieder vergessen oder noch vor sich liegen hat, der kann mit Hilfe dieses Tutorials von Delphic dieses Wissen erlernen bzw. auffrischen.
|-
![[Tutorial Objekt gedreht und dennoch nach vorne bewegt]]
{{Level_2}}
|[[Bild:Tutorial_Objekt_gedreht_und_dennoch_nach_vorne_bewegt_preview.gif|right]] "Objekt gedreht und dennoch nach vorne bewegt". 
SchodMC erklärt in diesem Tutorial wie man ein Objekt drehen und dabei trotzdem vorwärts bewegen kann. Quer fahrende Autos sind zwar praktisch zum Einparken Aber doch eher selten ;-)
|-
![[Tutorial Objekt immer um eigene Achse drehen]]
{{Level_2}}
|[[Bild:Tutorial_Objekt_immer_um_die_eigene_Achse_drehen_preview.gif|right]] "Objekt immer um eigene Achse drehen". 
Wenn ihr euer Objekt nun noch um die eigene Achse drehen wollt, seid ihr mit diesem Tutorial von SchodMC an der richtigen Adresse
|-
![[Tutorial Separating Axis Theorem]]
{{Level_2}}
|[[Bild:SAT_Kollision.jpg|right|128px]] "Separating Axis Theorem" 
Seth erklärt in diesem Tutorial wie man Polygonkollisionen mit Hilfe des ''Seperating Axis Theorem'' erkennen kann.
|-
![[Tutorial Kollision1]]
{{Level_1}}
|[[Bild:Tutorial_Kollision1_Coll2.png|128px|right]] "Kollision 1" 
Reinhard Niehoff fragte uns ob er ein Tutorial über Kollision schreiben könnte. Das konnten wir nicht ablehnen, und so entstand dieses Tutorial in dem grundlegende Kollisionsberechnungen erklärt werden. Weitere sollen folgen.
|-
![[Tutorial Kollision2]]
{{Level_2}}
|[[Bild:Tutorial_Kollision2_Thumb.png|128px|right]] "Kollision 2" 
Beim zweiten Tutorial gehts mehr in die Tiefe und einige Spezialfälle bei Kugel-Polygon-Kollisionen werden erläutert. Mit dabei: Die [[Werkzeugkiste]] mit nützlichen Funktionen.
|-
![[Tutorial Kollision3]]
{{Level_3}}
|[[Bild:Tutorial_Kollision3_Thumb.png|128px|right]] "Kollision 3" 
Beim letzten Tutorial dieser Serie gehts darum, wie man die bisherigen Ansätze in einem Programm unterbringt.
|-
|}

== Grafik und Modellierung ==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial Modellierung eines Low-Poly Menschen Teil 1]]
{{Level_4}}
|[[Bild:Tutorial_Low-Poly-Mensch1_preview.jpg|right]] "Modellierung eines Low-Poly-Menschen". 
Die Modellierung von organischen "Objekten" gehört mit zu den kompliziertesten Aufgaben, die es beim Modelling gibt. Wie man einen Menschen mit aus möglichst wenigen Polygonen mit dem Programm 3D Studio Max erstellen kann wird in diesem Tutorial von Sascha Willems erklärt.
|-
![[Tutorial Modellierung eines Low-Poly Menschen Teil 2]]
{{Level_4}}
|[[Bild:Tutorial_Low-Poly-Mensch2_preview.jpg|right]] "Kleider machen Leute (UVW-Mapping)". 
Nun spendiert Sascha Willems seinem Menschen aus dem 1. Tutorial eine schmucke Uniform, so dass er sich endlich in der Öffentlichkeit blicken lassen kann.
|-
|}

== Skripte ==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial Scripting mit JvInterpreterProgram]]
{{Level_2}}
|[[Bild:Tutorial_JvInterpreter_preview.png|right]] "Skripting mithilfe der Jedi-Code-Library". 
SchodMC erklärt hier wie man mit relativ wenig Aufwand Skripte in eigene Programme integrieren kann.
|-
![[Tutorial Scriptsprachen Teil 1]]
{{Level_5}}
|[[Bild:Tutorial_Skriptsprachen1_preview.gif|right]] "Scriptsprachen Teil 1 - Einführung". 
Für alle die schon immer einmal wissen wollten wie ein Compiler arbeitet ist diese Tutorial-Reihe von Delphic genau das richtige.

Der erste Teil widmet sich der Lexikalischen Analyse und dem Parsen des Quellcodes
|-
![[Tutorial Scriptsprachen Teil 2]]
{{Level_5}}
|[[Bild:Tutorial_Skriptsprachen2_preview.gif|right]] "Scriptsprachen Teil 2 - Virtuelle Computer und Code Erzeugung". 
Für alle die schon immer einmal wissen wollten wie ein Compiler arbeitet ist diese Tutorial-Reihe von Delphic genau das richtige.

Der zweite Teil beschreibt den Bau einer VM und der Codeerzeugung
|-
|}

== Delphi allgemein ==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
! [[Tutorial Debugging]]
{{Level_2}}
| [[Bild:Tutorial Debugging.gif|right]] "Debugger benutzen und andere praktische Tipps" 
In diesem Tutorial werdet von Delphic mit der Nutzung des Delphi-Debuggers eingeführt. Auch werden Wege zur Vermeidung von Fehlern aufgezeigt. Genauso findet Ihr aber auch in diesem Tutorial Hinweise, zu häufig begangenen Fehlern und deren Ursachen.
|-
! [[Tutorial Komponentenentwicklung]]
{{Level_2}}
| [[Bild:Tutorial Komponentenentwicklung.png|right]] "Komponentenentwicklung" 
In diesem Tutorial werdet ihr ein wenig tiefer in die Entwicklung von Komponenten unter Delphi eingeführt. Es wird Grundwissen auf diesem Gebiet vorausgesetzt.
|-
![[Tutorial Multithreading]]
{{Level_3}}
|[[Bild:Tutorial_Multithreading.gif|right]] "Das Prinzip der Dualität". 
Threads sind ein erweitertes Prinzip des bekannten Multitasking und werden innerhalb eines Programmes oft dazu genutzt, verschiedene Aufträge gleichzeitig abzuarbeiten. LossyEx erklärt euch hier deren Nutzung.
|-
! [[Tutorial Software-Synthesizer]]
{{Level_4}}
| [[Bild:Noexist.jpg|right]] "Software-Synthesizer" 
Computerspiele bestehen nicht nur aus Grafik. Dieses Tutorial widmet sich einem ganz anderen Bereich der Spieleprogrammierung: Der Erzeugung von synthetischen Sounds und Musik.
|}

== Rendertechniken ==
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
! [[Tutorial Frustum Culling]]
{{Level_1}}
| [[Bild:Tutorial Frustum Culling.jpg|right]] "Frustum Culling" 
Frustum Culling ist eine einfache Möglichkeit die Rendergeschwindigkeit zu erhöhen, da man damit schon vor dem Senden der Daten an die Grafikkarten feststellen kann, welche Objekte sich im Blickfeld des Spielers befinden und welche nicht.
|-
! [[Tutorial Octree]]
{{Level_1}}
| [[Bild:Tutorial Octree preview.jpg|right]] "Octrees" 
Octrees sind eine einfach zu implementierende, aber sehr effiziente Möglichkeit um besonders Outdoor-Szenen abhängig vom Betrachterblickfeld stark zu beschleunigen. In diesem Tutorial zeigt Shadow euch eine komplette Implementation eines Octrees inklusive ausgiebigem Quellcode.
|-
! [[Tutorial Charakteranimation]]
{{Level_4}}
| [[Bild:Tutorial_na.jpg|right]] "Charakteranimation" 
Wer menschliche Charaktere oder Tiere lebendig aussehend animieren will, kommt mit herkömmlichen Mitteln wie Translation und Rotation der Modelview-Matrix nicht weiter. In diesem Tutorial erklärt euch glAwesome, wie ihr eure Meshes zum Leben erweckt.
|-
! [[Tutorial Raytracing - Grundlagen I]]
{{Level_4}}
| [[Bild:Tutorial_RaytracingI_thumb.jpg|right]] "Raytracing - Grundlagen I" 
Die Grundzüge des Raytracings Teil 1 - Von den Strahlen bis zur ersten Darstellung von Kugeln und Ebenen
|-
! [[Tutorial Raytracing - Grundlagen II]]
{{Level_4}}
| [[Bild:Tutorial_RaytracingI_thumb.jpg|right]] "Raytracing - Grundlagen II" 
Die Grundzüge des Raytracings Teil 2 - Einfache Basisobjekte, Transformationen und Phong-Lightning
|}

Tutorial SDL2 Installation

2014-04-06T15:42:18Z

Glawesome: /* Die richtigen Dateien am richtigen Ort */ überflüssiges Wort entfernt

glGetShaderiv

2014-04-06T12:08:20Z

Glawesome: Weiterleitung nach glGetShader erstellt

#REDIRECT: [[glGetShader]]

glGetShader

2014-04-06T12:07:25Z

Glawesome: /* Delphi-Spezifikation */ glGetShader -> glGetShaderiv

= glGetShader =

== Name ==
'''glGetShaderiv''' - Gibt Parameter von Shaderobjekten aus

 
== Delphi-Spezifikation ==

procedure '''glGetShaderiv'''(''shader'' : GLuint; ''pname'' : GLenum; ''params'' : PGLint)

== Parameter ==

{| border="1" rules="all"
! ''shader''
| Gibt das Shaderobjekt an, das abgefragt werden soll
|-
! ''pname''
| Gibt den gewünschten Objektparameter an. Zulässig sind '''GL_SHADER_TYPE''', '''GL_DELETE_STATUS''', '''GL_COMPILE_STATUS''', '''GL_INFO_LOG_LENGTH''' und '''GL_SHADER_SOURCE_LENGTH'''
|-
! ''params''
| Beinhaltet den Objektparameter
|}

== Beschreibung ==
'''glGetShader''' gibt nach ''params'' den Wert eines Parameters für einen spezifischen Shader aus. Folgende Parameter sind definiert:

===GL_SHADER_TYPE===

''params'' gibt '''GL_VERTEX_SHADER''' aus, wenn ''shader'' ein Vertexshaderobjekt ist, und '''GL_FRAGMENT_SHADER''', wenn ''shader'' ein Fragmentshaderobjekt ist.

===GL_DELETE_STATUS===

''params'' gibt '''GL_TRUE''' aus, wenn der Shader zur Löschung markiert wurde, anderenfalls wird '''GL_FALSE''' ausgegeben.

===GL_COMPILE_STATUS===

''params'' gibt '''GL_TRUE''' aus, wenn die letzte Kompilier-Operation mit dem Shader erfolgreich verlaufen ist, anderenfalls wird '''GL_FALSE''' ausgegeben.

===GL_INFO_LOG_LENGTH===

''params'' gibt die Anzahl der Zeichen im Information-Log des Shaders (einschließlich der Null-Terminierung) aus. Die Größe des Zeichenpuffers wird zum Beispiel für das Abspeichern des Information-Log benötigt. Wenn der Shader kein Information-Log hat, wird 0 ausgegeben.

===GL_SHADER_SOURCE_LENGTH===

''params'' gibt die Summe der Längen der Shader-Sourcecodes (einschließlcih der Null-Terminierung) aus. Die Größe des Zeichenpuffers wird zum Beispiel für das Abspeichern des Shader-Sourcecodes benötigt. Wenn kein Sourcecode vorhanden ist, wird 0 ausgegeben.

 

== Hinweise ==
'''glGetShader''' ist nur verfügbar, wenn die verwendete OpenGL-Version größer gleich 2.0 ist.

Wenn ein Fehler generiert wird, wird der Inhalt von ''params'' nicht verändert.

== Fehlermeldungen ==
'''GL_INVALID_VALUE''' wird generiert, wenn ''shader'' kein von OpenGL erzeugter Wert ist.

'''GL_INVALID_OPERATION''' wird generiert, wenn ''shader'' sich nicht auf ein Shaderobjekt bezieht.

'''GL_INVALID_ENUM''' wird generiert, wenn ''pname'' ein unzulässiger Wert ist.

'''GL_INVALID_OPERATION''' wird generiert wenn '''glGetShader''' innerhalb eines [[glBegin]]-[[glEnd]] Blocks aufgerufen wird.

== Zugehörige Wertrückgaben ==
[[glGetShaderInfoLog]] mit dem Argument ''shader''

[[glGetShaderSource]] mit dem Argument ''shader''

[[glIsShader]]

== Siehe auch ==
[[glCompileShader]], [[glCreateShader]], [[glDeleteShader]], [[glGetProgram]], [[glShaderSource]]

[[Kategorie:GL|GetShader]]

Tutorial SDL2 Installation

2014-04-04T20:42:40Z

Glawesome: /* DLL-Fehlermeldung */ Kategorie hinzugefügt

Tutorial GL3+

2014-04-04T20:16:07Z

Glawesome: /* Sonstige */

Auf dieser Seite findet ihr alle Tutorials zum Thema OpenGL3 (und neueren OpenGL-Versionen), die DelphiGL.com zu bieten hat. Falls ihr zu einem Thema kein Tutorial findet könnte es sein, dass es bereits ein Tutorial in [[Tutorial deprecated OpenGL|deprecated GL]] gibt, das sich leicht in aktuelles OpenGL3 übersetzen lässt. Tutorials, die nicht direkt etwas mit OpenGL zu tun haben, findet ihr auf der Seite [[Tutorial Allgemeines]].

=Hinweise=
Das Ganze ist noch eine Baustelle. Bitte den zugehörigen [http://www.delphigl.com/forum/viewtopic.php?f=21&t=11133 Foren-Thread] beachten.

==Hinweis für alle Programmieranfänger==
Falls ihr OpenGL nutzen wollt aber noch keinerlei Programmiererfahrung habt, so solltet ihr zuerst eine Programmiersprache lernen. Das muss nicht unbedingt Pascal sein. Insbesondere solltet ihr sicher mit Pointern umgehen können.

DGL kann folgende Tutorials empfehlen:

{|{{Prettytable_B1}} width="100%"
!Link
!Sprache
!Beschreibung
|-
|[http://www.delphi-treff.de/tutorials/ Delphitutorials bei www.delphi-treff.de]
|{{Deutsch}}
|Delphi Source der Delphi Treff entstand durch den Zusammenschluss von Delphi-Source und dem Delphi-Treff und wurde mittlerweile wieder in Delphi-Treff umbenannt. Diese Community verfügt über eine ausgezeichnete Sammlung von Tutorials zum Thema "Delphiprogrammierung". Es werden nicht nur die Grundlagen erklärt sondern nahezu alle Bereiche der Programmierung mit Delphi. Außerdem verfügt diese Community über ein Forum welches mit seiner ''Bastelecke'' auch für Anfänger geeignet ist.
|-
|[http://crashkurs.christian-stelzmann.de/ Crashkurs von Christian Stelzmann]
|{{Deutsch}}
|Der Crashkurs von Christian erklärt neben den Grundlagen zur und über die Sprache auch die IDE anhand von zahlreichen einfachen Beispielen, die den Einstieg in Delphi stark vereinfachen und so eine einfache Einführung in die Arbeit mit Delphi bieten.
|-
|}

''Wer sehen möchte was DGLer aus dem hier Gelernten und ihrer Kreativität so machen, findet Beispiele davon in der [[DGL_Projekte]]-Ecke.''

=Tutorials=
{{Hinweis|Alle Tutorials sind der [[:Kategorie:Tutorial]] zugeordnet.}}

<div align="center">
{|{{Prettytable_B1}} width="100%"
!width="15%"|Schwierigkeitsgrad
!Bedeutung
|-
|{{Level_1}}
|Jeder Schritt wird ausführlich erklärt. Absolut Einsteigertauglich.
|-
|{{Level_2}}
|Verständnis der Grundprinzipien wird voraus gesetzt. Die Materie bleibt aber einfach.
|-
|{{Level_3}}
|Ihr wisst um was es geht. Es wird erwartet, dass ihr selbst das Thema weiterdenkt.
|-
|{{Level_4}}
|Das Tutorial bietet euch einen Einstieg. Es wird erwartet, dass ihr euch selbst noch eingehender mit den beschriebenen Techniken befasst. Für Fragen steht unser Forum zur Verfügung.
|-
|{{Level_5}}
|Um das Tutorial zu verstehen werden Kenntnisse auf dem entsprechenden Gebiet vorausgesetzt, welche über Grundwissen hinausgehen. Es wird erwartet, dass ihr euch eingehender mit dem Thema auseinandersetzt und auch andere Quellen lest/gelesen habt. Für Fragen steht unser Forum zur Verfügung.
|}
</div>

== Einsteiger-Tutorials ==
<div align="center">
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial OpenGL3 Lektion 1]]
{{Level_1}}
|[[Bild:Tutorial_na.jpg|right]] "Das erste Dreieck" 
Beschreibungstext

|-
![[Tutorial OpenGL3 Lektion 2]]
{{Level_1}}
|[[Bild:Tutorial_na.jpg|right]] "Ein rotierender Würfel" 
Beschreibungstext

|-
![[Tutorial OpenGL3 Lektion 3]]
{{Level_1}}
|[[Bild:Tutorial_na.jpg|right]] "Texturen" 
Beschreibungstext

|-
![[Tutorial OpenGL3 Lektion 4]]
{{Level_1}}
|[[Bild:Tutorial_na.jpg|right]] "Beleuchtung" 
Beschreibungstext

|}
</div>

== Sonstige ==
<div align="center">
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial SDL2 Installation]]
{{Level_1}}
|[[Bild:Tutorial_na.jpg|right]] "Installation von SDL2" 
Wer mit SDL2 entwickeln will, muss erstmal ein paar Einstellungen in seiner IDE vornehmen. Welche das sind und wie man vorgeht, wird hier Schritt für Schritt erklärt.

|-
![[Tutorial OpenGL3]]
{{Level_1}}
|[[Bild:Tutorial_na.jpg|right]] "Tutorialreihe OpenGL3" 
Dies sollte eine Tutorialreihe zu OpenGL3 werden, die leider nie fertig geworden ist. Nichtsdestotrotz kann man einiges daraus lernen.

|-
![[Tutorial OpenGL3 Zeichenkontext]]
{{Level_1}}
|[[Bild:Tutorial_na.jpg|right]] "Erstellung eines Renderkontexts" 
Hier wird erklärt, wie man einen aktuellen Renderkontext erstellt, ohne zusätzliche Bibliotheken wie SDL2 einzusetzen.

|}
</div>

Tutorial SDL2 Installation

2014-04-04T20:07:37Z

Glawesome:

Tutorial SDL2 Installation

2014-04-04T20:00:46Z

Glawesome: Die Seite wurde neu angelegt: „In diesem Tutorial wird dir gezeigt, wie du deine Entwicklungsumgebung so einrichtest, dass du SDL2-Programme entwickeln kannst. Dies ist Voraussetzung für …“

In diesem Tutorial wird dir gezeigt, wie du deine Entwicklungsumgebung so einrichtest, dass du SDL2-Programme entwickeln kannst. Dies ist Voraussetzung für [[Tutorial OpenGL3 Lektion 1]]. Auch wenn das Prinzip überall gleich ist, hängen die Details von der jeweils verwendeten Programmiersprache, von der Entwicklungsumgebung und vom Betriebssystem ab. Daher ist der Rest des Artikels nach Programmiersprache und IDE aufgeteilt.

==Code::Blocks (C++) unter Windows==
===SDL2 herunterladen===
Das erste, was wir benötigen, ist die Library SDL2 selbst. Diese lädst du dir [https://www.libsdl.org/download-2.0.php hier] herunter. Da wir Entwickler sind, brauchen wir nur, was im Abschnitt "Development Libraries" angeboten wird. Wer [http://www.codeblocks.org/ Code::Blocks] einsetzt, verwendet in der Regel den MinGW-Compiler. Dies ist dann der Fall, wenn man den Compiler gleichzeitig mit Code::Blocks installiert hat. Ist dies der Fall, speichert man als die Datei "SDL2-devel-2.0.3-mingw.tar.gz" auf dem Computer. Die Versionsnummer kann sich natürlich schon geändert haben, wenn du dieses Tutorial liest. Solange sie mit 2.0 beginnt, sollte alles so funktionieren, wie hier beschrieben.
===Archiv entpacken===
Die heruntergeladene Datei ist ein Archiv, also eine Datei in der weitere Dateien und Ordner komprimiert gespeichert sind. Schließlich wäre es mühsam, 100 Dateien einzeln herunterzuladen, nicht wahr? ;) Um das Archiv zu entpacken, benötigst du ein Archivprogramm auf deinem Computer. Auf den meisten Computern ist das ohnehin installiert. Falls dies bei dir nicht der Fall ist, kann ich [http://www.7-zip.org/ 7-zip] empfehlen, welches kostenlos (sogar open-source) ist und sehr viele Formate lesen und schreiben kann - insbesondere auch das Format tar.gz. Wenn du das heruntergeladene Archiv entpackt hast, befindet sich auf deiner Festplatte ein Ordner "SDL2-2.0.3" (oder eine andere Versionsnummer).
===Die richtigen Dateien am richtigen Ort===
Damit der Compiler die heruntergeladenen Code-Dateien auch findet, müssen wir ihm entweder sagen, wo sich diese befinden. Ich rate davon ab, das lokale Downloadverzeichnis (wo sich die Dateien bei dir vermutlich jetzt befinden) als Include-Pfad zu verwenden. Suche dir ein Verzeichnis auf der Festplatte aus, der deinem Ordnungssystem entspricht - auf deinem Computer herrscht doch Ordnung, oder?! ;) 
Der Einfachheit halber werde ich im Folgenden einfach annehmen, dass das Verzeichnis ''C:\include'' heißt. Darin erstellst du nun einen Ordner namens "SDL2". Nun wechselst du in das von dir entpackte Verzeichnis nach ''SDL2-2.0.3\include'' und kopierst alle darin enthaltenen Dateien nach ''C:\include''. 
Außerdem brauchen wir noch ein zweites Verzeichnis für Linker-Dateien. Dieses nenne ich hier einfach mal ''C:\lib''. Dorthin werden alle .a-Dateien kopiert, die sich im Ordner ''SDL2-2.0.3\i686-w64-mingw32\lib'' (wenn dein Programm 32bit ist) bzw. ''SDL2-2.0.3\x86_64-w64-mingw32\lib'' (falls du ein 64bit-Programm schreibst) befinden. Falls du unsicher bist, brauchst du wahrschenlich die 32bit-Version - auch wenn dein Betriebssystem 64bittig ist!
===Projekteinstellungen===
Falls noch nicht geschehen, startest du nun Code::Blocks und erstellst ein neues Projekt (Konsolenanwendung, "Hello World"-Beispiel). Um sicherzugehen, dass alles andere funktioniert, kompilierst du deine Anwendung erstmal und führst sie aus. 
Ist dies erfolgreich, klickst du im Menü auf "Project" -> "Build options..." und wählst in dem sich öffnenden Fenster den Reiter "Search directories". Dieser enthält wiederum zwei Unterreiter "Compiler" und "Linker". Beim Unterreiter "Compiler" klickst du auf "Add" und wählst ''C:\include'' aus. Auf die gleiche Weise wählst du beim Unterreiter "Linker" das Verzeichnis ''C:\lib'' aus.
Danach wechselst du noch zum Reiter "Linker settings" (neben "Search directories") und fügst folgende Zeile in die Box "other linker options" ein:
-lmingw32 -lSDL2main -lSDL2 -lopengl32
Anschließend natürlich noch mit einem Klick auf OK bestätigen. 

Folgender Code sollte nun erfolgreich gebaut (kompiliert & gelinkt) werden können:
<source lang=cpp>#include <iostream>
#include <SDL2/SDL.h>

int main(int argc, char* args[])
{
if(SDL_Init(SDL_INIT_EVERYTHING) != 0)
std::cout << "SDL_Init failed!\n";
else
std::cout << "SDL_Init was successful!\n";

SDL_Quit();
return 0;
}</source>

===DLL-Fehlermeldung===
Bevor du jetzt "Fehlermeldung!" schreist: Ich sagte bauen, nicht ausführen ;) Die Ausführung funktioniert in der Tat noch nicht, da Windows bei der Ausführung des Programms vergeblich nach der Datei "SDL2.dll" sucht. Diese musst du erst noch in das Verzeichnis kopieren, in dem sich die exe-Datei deines Programms befindet. Du findest sie im Ordner ''SDL2-2.0.3\lib\x86'' (32bit) bzw. in ''SDL2-2.0.3\lib\x64'' (64bit).

Tutorial GL3+

2014-04-04T17:45:15Z

Glawesome: Die Seite wurde neu angelegt: „Auf dieser Seite findet ihr alle Tutorials zum Thema OpenGL3 (und neueren OpenGL-Versionen), die DelphiGL.com zu bieten hat. Falls ihr zu einem Thema kein Tuto…“

Auf dieser Seite findet ihr alle Tutorials zum Thema OpenGL3 (und neueren OpenGL-Versionen), die DelphiGL.com zu bieten hat. Falls ihr zu einem Thema kein Tutorial findet könnte es sein, dass es bereits ein Tutorial in [[Tutorial deprecated OpenGL|deprecated GL]] gibt, das sich leicht in aktuelles OpenGL3 übersetzen lässt. Tutorials, die nicht direkt etwas mit OpenGL zu tun haben, findet ihr auf der Seite [[Tutorial Allgemeines]].

=Hinweise=
Das Ganze ist noch eine Baustelle. Bitte den zugehörigen [http://www.delphigl.com/forum/viewtopic.php?f=21&t=11133 Foren-Thread] beachten.

==Hinweis für alle Programmieranfänger==
Falls ihr OpenGL nutzen wollt aber noch keinerlei Programmiererfahrung habt, so solltet ihr zuerst eine Programmiersprache lernen. Das muss nicht unbedingt Pascal sein. Insbesondere solltet ihr sicher mit Pointern umgehen können.

DGL kann folgende Tutorials empfehlen:

{|{{Prettytable_B1}} width="100%"
!Link
!Sprache
!Beschreibung
|-
|[http://www.delphi-treff.de/tutorials/ Delphitutorials bei www.delphi-treff.de]
|{{Deutsch}}
|Delphi Source der Delphi Treff entstand durch den Zusammenschluss von Delphi-Source und dem Delphi-Treff und wurde mittlerweile wieder in Delphi-Treff umbenannt. Diese Community verfügt über eine ausgezeichnete Sammlung von Tutorials zum Thema "Delphiprogrammierung". Es werden nicht nur die Grundlagen erklärt sondern nahezu alle Bereiche der Programmierung mit Delphi. Außerdem verfügt diese Community über ein Forum welches mit seiner ''Bastelecke'' auch für Anfänger geeignet ist.
|-
|[http://crashkurs.christian-stelzmann.de/ Crashkurs von Christian Stelzmann]
|{{Deutsch}}
|Der Crashkurs von Christian erklärt neben den Grundlagen zur und über die Sprache auch die IDE anhand von zahlreichen einfachen Beispielen, die den Einstieg in Delphi stark vereinfachen und so eine einfache Einführung in die Arbeit mit Delphi bieten.
|-
|}

''Wer sehen möchte was DGLer aus dem hier Gelernten und ihrer Kreativität so machen, findet Beispiele davon in der [[DGL_Projekte]]-Ecke.''

=Tutorials=
{{Hinweis|Alle Tutorials sind der [[:Kategorie:Tutorial]] zugeordnet.}}

<div align="center">
{|{{Prettytable_B1}} width="100%"
!width="15%"|Schwierigkeitsgrad
!Bedeutung
|-
|{{Level_1}}
|Jeder Schritt wird ausführlich erklärt. Absolut Einsteigertauglich.
|-
|{{Level_2}}
|Verständnis der Grundprinzipien wird voraus gesetzt. Die Materie bleibt aber einfach.
|-
|{{Level_3}}
|Ihr wisst um was es geht. Es wird erwartet, dass ihr selbst das Thema weiterdenkt.
|-
|{{Level_4}}
|Das Tutorial bietet euch einen Einstieg. Es wird erwartet, dass ihr euch selbst noch eingehender mit den beschriebenen Techniken befasst. Für Fragen steht unser Forum zur Verfügung.
|-
|{{Level_5}}
|Um das Tutorial zu verstehen werden Kenntnisse auf dem entsprechenden Gebiet vorausgesetzt, welche über Grundwissen hinausgehen. Es wird erwartet, dass ihr euch eingehender mit dem Thema auseinandersetzt und auch andere Quellen lest/gelesen habt. Für Fragen steht unser Forum zur Verfügung.
|}
</div>

== Einsteiger-Tutorials ==
<div align="center">
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial OpenGL3 Lektion 1]]
{{Level_1}}
|[[Bild:Tutorial_na.jpg|right]] "Das erste Dreieck" 
Beschreibungstext

|-
![[Tutorial OpenGL3 Lektion 2]]
{{Level_1}}
|[[Bild:Tutorial_na.jpg|right]] "Ein rotierender Würfel" 
Beschreibungstext

|-
![[Tutorial OpenGL3 Lektion 3]]
{{Level_1}}
|[[Bild:Tutorial_na.jpg|right]] "Texturen" 
Beschreibungstext

|-
![[Tutorial OpenGL3 Lektion 4]]
{{Level_1}}
|[[Bild:Tutorial_na.jpg|right]] "Beleuchtung" 
Beschreibungstext

|}
</div>

== Sonstige ==
<div align="center">
{|{{Prettytable_B1}} width="100%"
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial OpenGL3]]
{{Level_1}}
|[[Bild:Tutorial_na.jpg|right]] "Tutorialreihe OpenGL3" 
Dies sollte eine Tutorialreihe zu OpenGL3 werden, die leider nie fertig geworden ist. Nichtsdestotrotz kann man einiges daraus lernen.

|-
![[Tutorial OpenGL3 Zeichenkontext]]
{{Level_1}}
|[[Bild:Tutorial_na.jpg|right]] "Erstellung eines Renderkontexts" 
Hier wird erklärt, wie man einen aktuellen Renderkontext erstellt, ohne zusätzliche Bibliotheken wie SDL2 einzusetzen.

|}
</div>

Performance

2014-03-30T18:11:18Z

Glawesome:

__TOC__

Dieser Artikel liefert einige Tipps dazu wie man eine OpenGL-Anwendung optimieren kann. Einige der hier genannten Tipps schließen sich gegenseitig aus. Welche Vorgehensweise die beste ist hängt immer davon ab wo gerade der Engpass liegt. Es bringt zum Beispiel wenig den Shader zu optimieren, wenn eigentlich die zu langsame CPU das Problem ist.

=== Grundlagen ===
Die folgenden Tipps sind eigentlich Pflicht, insbesondere da sie meist leicht zu realisieren sind. Beherzigt man diese überhaupt nicht, muss man sich nicht über eine unglaublich langsame Anwendung wundern. Die Reihenfolge gibt so ungefähr die Wichtigkeit an.
# Schließe nicht sichtbare Polygone so schnell wie möglich vom Rendering aus.
#* Aktiviere [[Backface Culling]].
#* Benutze [[Frustum Culling]].
#* Vor allem bei statischer Geometrie (die sich nicht bewegt) bieten sich die etablierten [[Techniken_und_Algorithmen#Raumunterteilungstechniken|Raumunterteilungstechniken]] wie BSP-Tree, Quad-Tree, usw. an.
# Vermeide Kommunikation zwischen CPU und GPU.
#* Lade nicht deine Texturen/Vertexdaten in jedem Frame neu auf die Grafikkarte hoch. Vermeide den Immediate Mode, also [[glBegin]]() und [[glEnd]](). Sofern du aber nur ein, zwei einzelne Dreiecke rendern möchtest ist der Immediate Mode akzeptabel.
#* Verwende [[VBO|Vertexbuffer-Objects]] - am besten in Kombination mit [[Vertex Array Object]]s. In sehr alten OpenGL-Programmen kann man stattdessen [[Displayliste]]n verwenden.
# Verwende glDraw***-Aufrufe sparsam. Hiermit sind ALLE Befehle gemeint die irgendetwas rendern, z.B. [[glDrawArrays]], [[glDrawElements]], ..., aber auch [[glMultiDrawArrays]], usw...
#* Lieber ein paar Polygone mehr rendern, wenn du dadurch glDraw***-Aufrufe einsparen kannst.
#* Es spielt so gut wie keine Rolle, ob du 500 oder 1 Polygon renderst, da ein glDraw***-Aufrufe alleine schon ziemlich viel Zeit braucht.
# Optimiere deine Modelle. Nutze den Mesh-Optimierer in deiner 3D-Modellierungssoftware. Dies bringt zwar meist nicht viel, ist aber ja auch nicht mehr als ein Knopfdruck.
# Die Grafikkarte hat einen Cache für bereits vom Vertexshader verarbeitete Vertices. Dieser wird genutzt, wenn du [[Indices]] verwendest. Der Vertexshader muss also im optimalen Fall für jeden Vertex nur einmal ausgeführt werden, auch wenn der Vertex in mehreren Dreiecken verwendet wird. In jedem [[Mesh|geschlossenen]] und [[Mesh|2-mannigfaltigen]] Dreiecksnetz wird jeder Vertex im Durchschnitt von 6 Dreiecken verwendet. Hier lässt sich also so einiges an Speicher und Rechenleistung sparen.
# Nutze den [[Z-Buffer]] aus.
#* Sortiere nicht deine Polygone einzeln nach der Entfernung zur Kamera (Painters-Algorithm), sondern verwende den Z-Buffer.
#* Sofern du aufwendige Shader oder viele Texturen verwendest, rendere deine Objekte (nicht Polygone) von vorne nach hinten. Also grob sortieren und den Rest den Z-Buffer machen lassen.
#* Wenn du transparente Objekte hast, rendere zunächst von sortiert vorne nach hinten die undurchsichtigen Objekte. Die transparenten Objekte renderst du dann anschließend von hinten nach vorne.
# Vermeide wenn möglich häufige Shader-, Textur-, Material- und Statewechsel.
# Überlege ob es wirklich notwendig ist, am Anfang jedes Frames den Farbpuffer mittels [[glClear]] zu löschen. Wenn jeder Pixel garantiert mindestens einmal pro Frame überschrieben wird, kannst du so wahrscheinlich etwas Speicherbandbreite sparen.

===Performance Killer===
# Die OpenGL eigene Selektion wird nur schlecht als recht unterstützt. Eine [[Tutorial_ColorPicking|Color-Picking-Selection]] kann abhilfe leisten.
# [[glPushAttrib]] und glPopAttrib gelten laut [http://developer.amd.com/media/gpu_assets/GDC06-OpenGL_Tutorial_Day-Hart-OpenGL_03_Performance.pdf diesem ATI Dokument] als "State Evils", welche sich negativ auf die Performance auswirken.
# Sofern die Extension [http://www.opengl.org/registry/specs/ARB/texture_non_power_of_two.txt GL_ARB_texture_non_power_of_two] nicht unterstützt wird, könnte eine Grafikkarte bei Texturen deren Kantenlänge keiner 2er-Potenz entspricht (also z.B. 256, 512, 1024, ...) in den Software-Modus umschalten. Im Software-Modus wird die Grafikkarte komplett von der CPU emuliert. Das dies nicht schnell sein kann dürfte klar sein.

=== Fortgeschrittene Techniken ===
Die folgenden Tipps sind nicht so einfach zu realisieren oder erfordern Kenntnisse über fortgeschrittene Features wie [[Shader]], [[Instancing]]. Die Reihenfolge der Tipps ist hier nicht von Bedeutung.
# Ein glDraw*** wird nicht sofort ausgeführt, d.h. die CPU erhält die Kontrolle zurück, bevor die GPU fertig mit dem Rendern ist. Erst beim Vertauschen von Front- und Backbuffer ("[[SwapBuffers]]") oder einem expliziten [[glFinish]] wird synchronisiert. Folglich gebe zuerst der Grafikkarte was zu arbeiten, rechne dann deine Spiellogik, Physik, etc. auf der CPU und rufe dann erst [[SwapBuffers]] auf. Sowas geht natürlich nicht immer, aber man kann beispielsweise Physik und Rendern in zwei Frames aufsplitten. Also du berechnest immer die Physik für das nächste Frame, während die GraKa das aktuelle Frame rendert. Siehe auch [[glFlush]].
# Überlege ob du Grafikspeicher sparen kannst, indem du z.B. Texturkoordinaten oder Normalen zur Laufzeit im [[Shader]] berechnest. (Beispiel: [[Shader#Beispiel:_Heightmap-Terrain|Heightmap-Terrain]])
# Wenn du viele identische Objekte renderst, überlege ob du [[Instancing]] einsetzen kannst. Erfordert allerdings halbwegs aktuelle Grafikhardware.
# Überlege ob du aufwendige Berechnungen, z.B. ein [[GLSL_Partikel_2|Partikelsystem]], nicht besser vollständig auf der Grafikkarte realisierst. Stichworte: [[FBO|Framebuffer-Objects]] und [[Transform-Feedback]].
# Verzichte auf einen [[Geometryshader]], wenn du ihn nicht unbedingt benötigst.
# Mit [[Triangulation|Triangle Strips]] lässt sich die Anzahl der notwendigen Vertices (bzw. Indices) bis auf ein Drittel reduzieren. Auch hier kommt der Vertexcache der Grafikkarte zum Einsatz.
# Überlege ob du deine Modelle immer in höchster Detailstufe (mit Texturierung, Beleuchtung und anderen teuren Effekten) zeichnen musst, wenn nicht, verwende [[LOD]] (''Level-Of-Detail'').
# Überlege ob du bei statischen Szenen komplexe Beleuchtungsberechnungen durch [[Lightmaps]] ersetzen kannst. Lightmaps benötigen zwar einiges an Grafikspeicher, jedoch müssen Berechnungen z.B. für Schatten nur einmal durchgeführt werden. Dies funktioniert sowohl bei [[GLSL_Licht_und_Schatten|Shadow Maps]] als auch bei [[Volumetrische_Stencilschatten|volumetrischen Stencilschatten]]. Auch [[Reflexion]]en oder [[Kaustik]]en stellen kein Problem dar.

=== Shader ===
Die folgenden Tipps beschäftigen sich mit der Optimierung von [[Shader]]n. Auch hier ist die Reihenfolge nicht von Bedeutung.
# Vermeide den Universal-Shader. Shader-Wechsel sind zwar aufwendig, aber eine gigantische if-Verzweigung die für jeden Vertex und jeden Pixel (!) ausgeführt werden muss ist noch wesentlich aufwendiger. Optimiere deinen Shader für die Aufgabe die er erfüllen muss.
# Vermeide aufwendige Berechnungen im Shader. Möglicherweise ist es sinnvoll komplexe Berechnungen im voraus zu berechnen und im Shader eine Lookup-Textur zu verwenden. Sofern eine komplexe Berechnung nur von Uniform-Variablen abhängig ist, ist es oft sinnvoll einfach eine weitere Uniform-Variable zu spendieren und einmal auf der CPU zu berechnen.
# Verwende nach Möglichkeit die in GLSL [[Tutorial_glsl#Eingebaute_Funktionen|integrierten Funktionen]]. Diese Funktionen können zum Teil wesentlich schneller sein da sie zum Teil direkt in der Hardware implementiert sind.
# Optimiere deine Shader so weit wie möglich. Effizienz hat hier Vorrang vor der Lesbarkeit, da die Operationen möglicherweise millionenfach pro Frame ausgeführt werden. Im Fall der Fälle dann einfach mal etwas ausführlicher kommentieren.
# Versuche insbesondere aufwendige Operationen wie zum Beispiel eine Wurzel zu vermeiden. Bedenke das sich solche Operationen auch in eingebauten Funktionen wie beispielsweise {{INLINE_CODE|length}}, {{INLINE_CODE|distance}} und {{INLINE_CODE|normalize}} verstecken können.
# Vermeide Random-Access auf Texturen. Zwei nebeneinander liegende Texel einer Textur können üblicherweise schneller aus dem Speicher geladen werden als zwei Texel an völlig unterschiedlichen Positionen in der Textur. Nutze den GPU-Cache!
# Versuche nicht Speicher zu sparen, indem du Variablen im Shader zusammenfasst. Beispielsweise macht eine Variable {{INLINE_CODE|vec4 positionAndSize}} wenig Sinn, wenn Position und Größe nur wenig miteinander zu tun haben und du z.B. ständig mit {{INLINE_CODE|positionAndSize.xyz}} arbeitest. Verwende lieber separate Variablen, also {{INLINE_CODE|vec3 position}} und {{INLINE_CODE|float size}}. So kann der Compiler besser optimieren. Dies gilt natürlich nur für lokale Variablen im Shader. Wenn du mit dieser Methode Werte in einer Textur oder einem VBO zusammenfassen kannst, ist dies natürlich sehr sinnvoll!
# Es gibt diverse Tools mit denen du feststellen kannst wo genau deine Anwendung die meiste Zeit benötigt bzw. wo du optimieren solltest.
#* [http://developer.nvidia.com/object/nvperfkit_home.html NVIDIA PerfKit]
#* [http://news.developer.nvidia.com/2006/12/nvidia_perfgrap.html NVIDIA PerfGraph]
#* [http://developer.amd.com/gpu/shader/Pages/default.aspx AMD GPU ShaderAnalyzer]
#* bitte ergänzen...

=== Quellen / Links ===
* [http://developer.nvidia.com/object/gpu_programming_guide.html NVIDIA GPU Programming Guide]
* [http://developer.amd.com/media/gpu_assets/GDC06-OpenGL_Tutorial_Day-Hart-OpenGL_03_Performance.pdf OpenGL Performance Tuning, GDC 2006]

OpenGL3.x API

2014-03-21T11:11:15Z

Glawesome: /* API Übersicht */

=OpenGL3.1=
Hier folgend werden alle Funktionen aufgelistet, die mit OpenGL3.1 verfügbar sind.
==API Übersicht==
===Windows OpenGL Funktionen===
*[[wglCreateContextAttribsARB]] (Anmerkung:Diese Funktion kann nur mit einem gültigen OpenGL Context abgefragt werden und wird benötigt um ein gültigen OpenGL3 Context zu erstellen.)
===Error===
*[[glGetError]]
===Vertex Arrays===
*[[glVertexAttrib]]
*[[glVertexAttribPointer]]
*[[glEnableVertexAttribArray]]
*[[glDisableVertexAttribArray]]
*[[glEnable]]
*[[glDisable]]
*[[glPrimitiveRestartIndex]]
*[[glDrawArrays]]
*[[glMultiDrawArrays]]
*[[glDrawElements]]
*[[glMultiDrawElements]]
*[[glDrawRangeElements]]
*[[glDrawArraysInstanced]]
*[[glDrawElementsInstanced]]
===Buffer Object===
*[[glGenBuffers]]
*[[glDeleteBuffers]]
*[[glBindBuffer]]
*[[glBufferData]]
*[[glBufferSubData]]
*[[glMapBufferRange]]
*[[glMapBuffer]]
*[[glUnmapBuffer]]
*[[glFlushMappedBufferRange]]
*[[glCopyBufferSubData]]
===Vertex Array Object===
*[[glGenVertexArrays]]
*[[glDeleteVertexArrays]]
*[[glBindVertexArray]]
===Shader===
*[[glCreateShader]]
*[[glShaderSource]]
*[[glCompileShader]]
*[[glDeleteShader]]
*[[glCreateProgram]]
*[[glAttachShader]]
*[[glDetachShader]]
*[[glLinkProgram]]
*[[glUseProgram]]
*[[glDeleteProgram]]
*[[glGetActiveAttrib]]
*[[glGetAttribLocation]]
*[[glBindAttribLocation]]
*[[glGetUniformLocation]]
*[[glGetUniformBlockIndex]]
*[[glGetActiveUniformBlockName]]
*[[glGetActiveUniformBlock]]
*[[glGetUniformIndices]]
*[[glGetActiveUniformName]]
*[[glGetActiveUniform]]
*[[glUniform]]
*[[glUniformMatrix]]
*[[glBindBufferRange]]
*[[glBindBufferBase]]
*[[glUniformBlockBinding]]
*[[glTransformFeedbackVarings]]
*[[glGetTransformFeedbackVaying]]
*[[glValidateProgram]]
===Fragment Shaders===
*[[glBindFragDataLocation]]
*[[glGetFragDataLocation]]
===Coordinate Transformations===
*[[glDepthRange]]
*[[glViewport]]
===Asynchronous Queries===
*[[glBeginQuery]]
*[[glEndQuery]]
*[[glGenQueries]]
*[[glDeleteQueries]]
===Bedingungsabhängiges Rendern===
*[[glBeginConditionalRender]]
*[[glEndConditionalRender]]
===Transform Feedback===
*[[glBeginTransformFeedback]]
*[[glEndTransformFeedback]]
===Points===
*[[glPointSize]]
*[[glPointParameter]]
===Line Segments===
*[[glLineWidth]]
===Polygons===
*[[glFrontFace]]
*[[glCullFace]]
*[[glPolygonMode]]
*[[glPolygonOffset]]
===Pixel Rectangles===
*[[glPixelStore]]
===Texturierung===
*[[glActiveTexture]]
*[[glTexImage3D]]
*[[glTexImage2D]]
*[[glTexImage1D]]
*[[glCopyTexImage2D]]
*[[glCopyTexImage1D]]
*[[glTexSubImage3D]]
*[[glTexSubImage2D]]
*[[glTexSubImage1D]]
*[[glCopyTexSubImage3D]]
*[[glCopyTexSubImage2D]]
*[[glCopyTexSubImage1D]]
*[[glCompressedTexImage1D]]
*[[glCompressedTexImage2D]]
*[[glCompressedTexImage3D]]
*[[glCompressedTexSubImage1D]]
*[[glCompressedTexSubImage2D]]
*[[glCompressedTexSubImage3D]]
*[[glTexBuffer]]
*[[glTexParameter]]
*[[glGenerateMipmap]]
*[[glBindTexture]]
*[[glDeleteTextures]]
*[[glGenTextures]]
===Per-Fragment Operations===
*[[glScissor]]
*[[glSampleCoverage]]
*[[glStencilFunc]]
*[[glStencilFuncSeparate]]
*[[glStencilOp]]
*[[glStencilOpSeparate]]
*[[glDepthFunc]]
*[[glBlendEquation]]
*[[glBlendEquationSeparate]]
*[[glBlendFuncSeparate]]
*[[glBlendFunc]]
*[[glBlendColor]]
*[[glLogicOp]]
===Framebuffer Operationen===
*[[glDrawBuffer]]
*[[glDrawBuffers]]
*[[glColorMask]]
*[[glDepthMask]]
*[[glStencilMask]]
*[[glStencilMaskSeparate]]
*[[glClear]]
*[[glClearColor]]
*[[glClearDepth]]
*[[glClearStencil]]
*[[glClearBuffer]]
===Reading and Copying Pixels===
*[[glReadPixels]]
*[[glReadBuffer]]
*[[glClampColor]]
*[[glBlitFramebuffer]]
===Framebuffer Object===
*[[glBindFramebuffer]]
*[[glDeleteFramebuffers]]
*[[glGenFramebuffers]]
*[[glBindRenderbuffer]]
*[[glDeleteRenderbuffers]]
*[[glGenRenderbuffers]]
*[[glRenderbufferStorageMultisamlpe]]
*[[glRenderbufferStorage]]
*[[glFramebufferRenderbuffer]]
*[[glFramebufferTexture1D]]
*[[glFramebufferTexture2D]]
*[[glFramebufferTexture3D]]
*[[glFramebufferTextureLayer]]
*[[glCheckFramebufferStatus]]
===Spezielle Funktionen===
*[[glFlush]]
*[[glFinish]]
*[[glHint]]
===Zustand und Zustandsabfrage===
*[[glGetBooleanv]]
*[[glGetIntegerv]]
*[[glGetFloatv]]
*[[glGetDoublev]]
*[[glGetBooleani_v]]
*[[glGetIntegeri_v]]
*[[glIsEnabled]]
*[[glIsEnabledi]]
*[[glGetTexParameter]]
*[[glGetTexLevelParameter]]
*[[glGetTexImage]]
*[[glGetCompressedTexImage]]
*[[glIsTexture]]
*[[glGetString]]
*[[glIsQuery]]
*[[glGetQueryObject]]
*[[glIsBuffer]]
*[[glGetBufferParameter]]
*[[glGetBufferSubData]]
*[[glGetBufferPointer]]
*[[glIsVertexArray]]
*[[glIsShader]]
*[[glGetShader]]
*[[glIsProgram]]
*[[glGetProgram]]
*[[glGetAttachedShaders]]
*[[glGetShaderInfoLog]]
*[[glGetProgramInfoLog]]
*[[glGetShaderSource]]
*[[glGetVertexAttrib]]
*[[glGetVertexAttribPointer]]
*[[glGetUniform]]
*[[glIsFramebuffer]]
*[[glGetFramebufferAttachmentParameter]]
*[[glIsRenderbuffer]]
*[[glGetRenderbufferParameter]]

Renderkontext

2014-03-19T15:24:23Z

Glawesome: /* Siehe auch */

{{Template:Unvollständig|Hier fehlen noch einige Angaben zur Erzeugung (v.A. unter Linux!) und Verwendung. Zudem sollte noch mal jemand drüberschauen, ob die angegebenen Informationen zu den enthaltenen Info's korrekt sind.}}

Der [[Renderkontext]] enthält alle nötigen Informationen, die eine Zeichenfläche und die zu dieser zugeordneten Ressourcen beschreiben. Diese Informationen enthalten dabei Angaben zum verwendeten [[Pixelformat]], den Abmessungen der Zeichenfläche (Höhe, Breite, Aspekt-Ratio), sowie Angaben zur Lage der Datenpuffer für [[Farbpuffer|Farb-]], [[Schablonenpuffer|Stencil-]], [[Tiefenpuffer|Tiefen-]] und Transparenz-Informationen. Zudem enthält der Render-Kontext allgemeine Statusinformationen wie die Art und Dicke zu zeichnender Linien, die zum Zeichnen zu verwendenden Texturen sowie andere Angaben, die für das Zeichnen notwendig sind.

== Anlegen eines Renderkontext ==
{{Template:Hinweis|Dieser Abschnitt beschreibt das Vorgehen unter Windows. Unter Linux können Details abweichen (Wenn jemand mit Linux mehr Erfahrung hat, wäre eine Teilung und differenziertere Beschreibung erwünscht)}}

Um überhaupt mit OpenGL arbeiten zu können, muss zuerst einmal ein Renderkontext angelegt werden. Dabei muss man einen vorhandenen [[Gerätekontext]] (DC) zugrunde legen. Ein Renderkontext spannt sich dabei immer über den gesamten Gerätekontext und damit über den gesamten Clientbereich des Fensters oder das gesamte Speicher-Bitmap, zu dem der Gerätekontext gehört.

Beim Anlegen werden sowohl auf der Grafikkarte als auch im RAM abhängig von den Einstellungen des Gerätekontextes ([[Pixelformat]], Höhe, Breite...) diverse Speicherbereiche reserviert, in denen später dann [[Farbpuffer|Farb-]] oder [[Tiefenpuffer]], die Informationen der Statemachine, [[Textur]]en, [[Displayliste]]n oder [[VBO]]s abgelegt werden (natürlich werden auch einige Bereiche erst später dynamisch reserviert).
===Beispiel===
<source lang="pascal">var
DC, RC:HDC;
procedure TfrmMain.FormCreate(Sender: TObject);
begin
DC:=GetDC(Handle);
RC:=CreateRenderingContext(DC, //Device Contest
[opDoubleBuffered], //Optionen
32, //ColorBits
24, //ZBits
0, //StencilBits
0, //AccumBits
0, //AuxBuffers
0); //Layer
ActivateRenderingContext(DC, RC);
end;</source>

*'''DC''' ist der Gerätekontext an dem der Rendercontext hängt. Zum Beispiel der Kontext eines Formulars oder aber der eines Panels. Je nachdem wo später drauf gezeichnet werden soll.
*'''Optionen''' sind hinweise wie z.B: opDoubleBuffered. Diese Option gibt an, dass [[Doppelpufferung]] genutzt werden soll. TODO Bitte weitere Optionen bzw. Link wo man nachlesen kann.
*'''ColorBits''', hier 32, gibt die Farbtiefe an. 32 bedeutet, dass für die 4 Farbkanäle (Rot, Grün, Blau, Alpha(Transparenz)) jeweils 1Byte=8Bit zur Verfügung stehen. Das bedeutet für jeden Kanal können 256 Abstufungen genutzt werden. Das macht insgesamt 256^4 = ... verdammt viele!
*'''ZBits''', hier 24, gibt an wie viele Bits für den [[Tiefenpuffer]] reserviert werden. 24Bits bedeutet, dass Einträge von 0 bis 2^24=16,7Mio möglich sind. Je höher der Wert, desto feiner/genauer der [[Tiefentest]]. (Mehr dazu im Tiefetest-Artikel)
*'''StencilBits''' werden für den [[Feste_Funktionspipeline#Stencil_Test|Stencil Test]] benötigt. (Maskieren von Bildschirmteilen)
*'''AccumBits''' geben an, wie viele Bits im [[Akkumulationspuffer]] gespeichert werden können.
*'''AuxBuffer''' gibt an, wie viele Bits im Hilfspuffer gespeichert werden können.
*'''Layer''' gibt die Anzahl ebenen an.

=== Problem mit erweiterungsabhängigen Pixelformaten ===
Ein bekanntes Problem bei der Tatsache, dass ein Renderkontext an einen Gerätekontext gebunden ist und dass man das Pixelformat eines Gerätekontextes nur ein einziges Mal festlegen kann, ist, dass man für einige Einstellungen im Pixelformat erst wissen muss, ob die passenden Erweiterungen zur Verfügung stehen. Um das zu ermitteln muss man allerdings wiederum einen Renderkontext erstellt haben.

Um dieses Problem zu umgehen, wird häufig ein Testgerätekontext auf einem versteckten Fenster erstellt, auf dem dann ein Testrenderkontext erstellt wird, wo man die Erweiterungen abfragt.

Diese Problematik tritt häufig bei [[Multisampling]] ([[Antialiasing]]) auf, da dies eine entsprechende Erweiterung beziehungsweise die Fähigkeit der Hardware benötigt und im Pixelformat festgelegt sein muss.

== Einflussnahme auf den Renderkontext ==
Bei jedem Aufruf einer Funktion von OpenGL, die an der Art und Weise, wie etwas gezeichnet werden soll, oder die selbst etwas zeichnet, nimmt OpenGL Veränderungen an den im Renderkontext hinterlegten Angaben vor. Diese Veränderungen spiegeln dabei die auszuführende Operation (z.B. Ändern der Linienstärke beim Zeichnen mit GL_LINES) in Form einer Status-Änderung wieder (Ändern des Wertes, der die zu verwendende Linien-Breite angibt).

=== Renderkontextübergreifende Daten ===
OpenGL bietet (zumindest unter Windows) mittels [[wglShareLists]] die Möglichkeit, kontextspezifische Objekte wie Texturen oder Displaylisten übergreifend über zwei Renderkontexte zu verwenden. Dies ist zum Beispiel im Falle einer Editoranwendung hilfreich, die mehrere Viewports hat, die aus technischen Gründen nicht in einem Renderkontext liegen können. Für jeden Viewport alle Texturen und VBOs beziehungsweise Displaylisten zu laden, wäre natürlich viel zu großer Aufwand. Statt dessen benutzt man etwas wie wglShareLists, um die Objekte nur einmal laden zu müssen.

=== Das Thread-Problem ===
Ein Problem, auf das man im Zusammenhang mit dem Laden von Daten in den Renderkontext später eventuell treffen kann ist, dass man einen Renderkontext nur so lange verändern kann, wie man sich in demjenigen Thread befindet, in dem der Kontext erstellt wurde. Das heißt, dass man Texturen oder andere OpenGL-Objekte nicht aus einem nebenläufigen Lade-Thread heraus erstellen kann. Wohl aber kann man die Daten erstmal in den RAM laden und dann an den Hauptthread weiterreichen, der sie dann an die Grafikkarte schickt.

== Siehe auch ==
[[Tutorial_Quickstart]] 
[[Tutorial OpenGL3 Zeichenkontext]]

MipMaps

2014-03-19T15:19:29Z

Glawesome: Rechtschreibung, Kommasetzung

Mip Mapping (MIP = ''multum in parvo'' = vieles im Kleinen) ist eine Technik, welche die Darstellungsqualität von Bildern ([[Texturen]]) verbessert, wenn diese kleiner als in der ursprünglichen Größe dargestellt werden (bezogen auf die Auflösung des Bildes in Pixeln). Als angenehmer Nebeneffekt wird normalerweise auch weniger Rechenzeit benötigt, wenn ein Bild mit Hilfe von MipMaps verkleinert dargestellt wird. Dies wird jedoch durch einen vergrößerten Speicherplatzverbrauch zum Ablegen der MipMaps im Speicher (entweder Hauptspeicher oder Grafikkartenspeicher) ''erkauft''.

Wird ein Bild ohne MipMaps verkleinert dargestellt, dann erscheint dieses Bild (besonders bei einer [[Animation]]) oft unruhig, da sich die einzelnen Pixel oft verändern. Den Effekt kann man mit Rauschen oder Krisseln beschreiben und ist in der Regel unerwünscht. Es rührt daher, dass durch die Verkleinerung ausgehend vom Originalbild die Frequenzen der Zeilen und Spalten nicht korrekt behandelt werden.

Soll aus den [[Texel|Texeln]] der Textur das Zielpixel berechnet werden, so wird man in der Regel mehrere Texel zur Berechnung verwenden (siehe [[bilinear|bilineares Filtern]]). Benutzt man dabei statt der original Textur eine Mipmap, so spricht man auch von [[trilinear|trilinearer Filterung]]. Man kann die Ergebnisse des trinilearen Filterns sogar noch verbessern, indem man den [[Anisotropes Filtern|anisotropen Filteralgorithmus]] verwendet.
Das Gegenteil zum Mipmapping ist die [[Interpolation]] bei der Vergößerung von Bildern.

==Beispiel==

Dies ist das Bild in der originalen Größe von 256x256 Pixeln: [[Bild:Sf256.jpg|San Francisco Skyline]]

Soll nun dieses Bild in 64x64 Pixeln dargestellt werden, so wird normalerweise einfach nur jede vierte horizontale Zeile und jede vierte vertikale Spalte angezeigt: [[Bild:Sf64u.jpg]] Man kann erkennen, dass das Resultat sehr ''pixelig'' aussieht (Für Menschen ohne 200% Sehschärfe vielleicht mit einer Bildschirm Lupe etwas nachhelfen :-). Technisch gesprochen wurden die ''hohen Frequenzen'' des originalen Bildes nicht vor dem Verkleinern gefiltert, wodurch das Ergebnis durch [[Aliasing]] verfälscht wird.

Beim Mipmapping werden nun verschiedene Versionen des originalen Bildes im Speicher abgelegt, welche in der Regel jeweils um den Faktor 2 verkleinert sind. Die kleineren Bilder werden dabei jeweils korrekt ''Frequenz gefiltert'' verkleinert. Die einzelnen Verkleinerungsstufen nennt man dann '''MipMaps'''. Bei unserem Beispielbild würden folgende Bilder im Speicher abgelegt:

[[Bild:Sf256.jpg]] 256x256

[[Bild:Sf128.jpg]] 128x128

[[Bild:Sf64.jpg]] 64x64

[[Bild:Sf32.jpg]] 32x32

[[Bild:Sf16.jpg]] 16x16

[[Bild:Sf8.jpg]] 8x8

(sowie die Größen 4x4, 2x2 und 1x1 Pixel)

Vergleicht man nun das Bild mit 64x64 Pixeln mit dem obigen (nicht korrekt) verkleinertem, so fällt auf, dass die zweite Version wesentlich ''glatter'' aussieht. Dies sind, wie oben erwähnt, die nicht mehr vorhandenen zu hohen Frequenzen.
{|{{Prettytable}}
|valign="top"|[[Bild:Sf64u.jpg|framed|Verkleinert auf 64x64 ohne Mipmapping]]
|valign="top"|[[Bild:Sf64.jpg|framed|64x64 Mipmap]]
|-
|colspan="2"|Man beachte die unsymetrischen Spitzen der Türme.
|}

==OpenGL-Funktionen==
===Bis OpenGL 2.1 (deprecated)===
MipMaps können mit Hilfe der Funktion [[gluBuild1DMipmaps]] und [[gluBuild2DMipmaps]] einfach erzeugt werden, allerdings sind diese Funktionen recht langsam und man hat keinen Einfluss auf die Erstellung (und damit Qualität der MipMaps). Die MipMaps werden von der Funktion automatisch erzeugt und im Kontext der aktuellen mit [[glBindTexture]] gebundenen [[Textur]] aktiviert. Man kann die einzelnen ''Stufen'' der MipMap auch manuell erzeugen und an [[OpenGL]] übergeben, dazu ist der zweite Parameter (level) von [[glTexImage1D]], [[glTexImage2D]], [[glTexImage3D]] zu benutzen. Will man Mipmaps aus einer normalen Textur von OpenGL erzeugen lassen, kann dies durch das Setzen des "GENERATE_MIPMAP"-Flag in den Texture-Parameter vor dem Laden des Bildes mit '''glTexImage''' in den Mipmap-Level 0 geschehen. Die Veränderung des "Level 0"-Bildes, veranlasst OpenGL dann die anderen Mipmap-Level zu erzeugen/erneuern.
<source lang=pascal>glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
glTexImage2D(GL_TEXTURE_2D, 0, ...); // Laden der Textur in den Level 0</source>
Eine Generierung mittels '''[[glTexParameter]]''' und '''glTexImage''' ist '''gluBuildMipmaps''' aus Performanzgründen vorzuziehen. glTexParameter bietet weitere interessante Optionen für die Verwendung/Beeinflussung von Mipmaps.

===OpenGL 3.0 und neuer===
In OpenGL3 ruft man, nachdem man die "Level 0"-Texturdaten mittels [[glTexImage]] hochgeladen hat, die Funktion [[glGenerateMipmap]] auf. Wichtig ist außerdem, die Nutzung der damit generierten MipMaps zu aktivieren:
<source lang=pascal>glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); // letzter Parameter für trilineare Filterung</source>
Für den letzten Parameter kann man dabei auch jede andere Konstante nehmen, die den String "MIPMAP" im Namen trägt.

===Vorberechnete MipMaps===
Eine performante Alternative ist es, ein Texturformat zu verwenden, das MipMaps direkt mitspeichert, wie es z.B. bei [[DDS]] der Fall ist. Dort werden die MipMaps beim Export aus dem Bildbearbeitungsprogramm in der Datei abgelegt (sofern man das wünscht) und man kann Einfluss auf deren Generation nehmen (wie sie gefiltert werden, wie viele Stufen abgelegt werden, alternativ kann man die MipMap-Stufen sogar selbst erstellen). Die MipMaps werden dann in der eigenen Anwendung direkt aus der Datei mitgeladen. Diese Methode ist flexibler und vor allem beim Laden sehr viel schneller.

Texturesynthesis

2014-03-19T15:12:21Z

Glawesome: /* Was ist Texturesynthesis? */

== Was ist Texturesynthesis? ==
Häufig steht man vor dem Problem, dass man zwar in Textursammlung XY eine vom Prinzip her schöne [[Textur]] gefunden hat, diese jedoch aus diversen Gründen nicht sinnvoll nutzbar ist. Ein paar Beispiele:
* Die Textur ist zu klein. Würde man die Textur kacheln, sähe man dies sofort.
* Die Textur ist ein Foto und daher gar nicht kachelbar.
* Die Textur hat einige kleinere Stellen die "doof" aussehen. Beispielsweise größere Schatten in einer Fototextur können merkwürdig aussehen, wenn das Licht in der Szene nicht aus der entsprechenden Richtung kommt. Gleiches gilt für besonders auffällige Elemente deren Wiederholung man sofort sehen würde.
Sofern es sich um eine Textur mit nur lokaler Struktur handelt und man etwas Rechenleistung investiert, kann man diese Mängel ohne Verlust an Qualität beheben!

Texturesynthesis ist die Wissenschaft, die sich damit beschäftigt die grundlegende Struktur einer Textur weiterzuführen, OHNE Wiederholungen zu erzeugen. Der Standardalgorithmus beginnt mit einer Zufallstextur mit RGB-rauschen. Nun wird die Textur Pixel für Pixel durchlaufen und jeweils der Pixel aus der Inputtextur gewählt, dessen lokale Nachbarschaft best-möglich zum aktuellen Pixel passt.

Das ganze klappt nicht bei jeder Textur, erfordert etwas Rechenleistung, aber prinzipiell kann man aus einer kleinen Quelltextur beliebig große, kachelbare Texturen erzeugen! Ebenfalls ist es möglich, nur Teilbereiche einer Textur neu zu erzeugen.

== Beispiele ==
{{Hinweis|Dank freundlicher Genehmigung von [http://www.cgtextures.com/ cgtextures.com] kann ich hier einige Beispiele präsentieren. Die folgenden Beispiel-Texturen unterliegen wie das gesamte Wiki der [http://www.gnu.org/copyleft/fdl.html GNU Free Documentation License 1.2]. Dies gilt jedoch '''ausschließlich''' für die Texturen in diesem Artikel. Texturen die von [http://www.cgtextures.com/ cgtextures.com] heruntergeladen werden sind urheberrechtlich geschützt und unterliegen '''nicht''' dieser Lizenz!}}

Das erste Beispiel wurde mit dem Programm [[#MRFsynthesis|MRFsynthesis]] erstellt. Die Input-Textur ist links zu sehen. In der Masken-Textur rechts sind unerwünschte Bereiche mit schwarz (RGB: 0,0,0) übermalt. Die Textur hatte eine Originalgröße von 1600x1200 und wurde vor Anwendung des Tools auf 683x512 herunter skaliert. 
[[Bild:Rock-input.jpg]] [[Bild:Rock-mask.jpg]] 
Als Output bekommt man diese kachelbare Textur. Sie hat im Original eine Auflösung von 1300x1300. 
[[Bild:Rock-output.jpg]]

Ein weiteres Beispiel mit einer anderen Texturart. Auch dieses Beispiel wurde mit MRFsynthesis erzeugt. Die Schwierigkeit liegt hier darin, dass der Algorithmus nicht weiß was eine Pflanze ist, geschweige denn, wie eine Pflanze auszusehen hat. Die Masken Textur wurde etwas aufgehellt, da die Risse in der Erde sehr dunkel sind und sonst möglicherweise ausgeschlossen würden. 
[[Bild:Earth-input.jpg]] [[Bild:Earth-mask.jpg]] 
Die Qualität der Erd-Risse in der Outputtextur ist sehr gut. Insbesondere in der Originalauflösung (roter Kasten) sieht man den hohen Detailgrad. Die Pflanzen sehen allerdings leicht abgewetzt aus, da sie zum Teil nur aus einem einzigen Blatt bestehen. 
[[Bild:Earth-output.jpg]]

Das folgende Beispiel demostriert die Fähigkeiten des Algorithmus auch "doofe" Stellen aus einem Bild zu entfernen ohne das Bild vollständig neu zu konstruieren. Wen blöde Stromleitungen auf Urlaubsbildern nerven, dem kann geholfen werden. Das Bild wurde mit dem [http://de.wikipedia.org/wiki/GIMP GIMP]-Plugin [[#Resynthesizer|Resynthesizer]] bearbeitet. 
[[Bild:Gardasee-in.jpg]] [[Bild:Gardasee-mask.jpg]] [[Bild:Gardasee-out.jpg]]

== Tools ==
Es gibt viele verschiedene Tools die diese Technik beherrschen. Im folgenden werden einige davon vorgestellt. Es gibt aber sicher noch mehr, einfach mal googlen.

=== MRFsynthesis ===
Das Tool hat den klangvollen Namen ''"Semi Causal Nonparametric Markov Random Field Texture Synthesis"'', oder kurz ''"MRFsynthesis"''. Es gibt kein Binary, aber der [http://www.texturesynthesis.com/texture.htm Quellcode ist hier verfügbar]. In den einzelnen Quellcodedateien findet sich ein Lizenztext als Kommentar. Die mit MRFsynthesis erzeugten Texturen dürfen für beliebige Zwecke eingesetzt werden, also insbesondere auch kommerziell. Das Tool selbst ist kostenlos verfügbar und darf auch verändert werden. Es darf jedoch nicht kommerziell verbreitet werden.

Vermutlich, da der Code aus dem Jahr 2002 stammt, muss man leider etwas am Quellcode fummeln bis aktuelle Compiler den Code akzeptieren. Sollte aber ziemlich offensichtlich sein, in ''Option.h'' musste ich ein ''using namespace std;'' hinzufügen und in ''nr.h'' zweimal eine ungenutzte Funktion ''fmin'' auskommentieren. Ich nutze Fedora 10 Linux mit gcc 4.3.2 und kann daher nichts darüber sagen, ob es möglich ist das ganze unter Windows zum laufen zu bringen.

Das Programm ist leider nicht für Mehrkern-CPUs geschrieben, man kann aber einfach für jeden Kern das Programm einmal starten. Man muss sowieso immer etwas an den Parametern spielen, bis man ein sinnvolles Ergebnis erhält. Je nach verwendetem Algorithmus und Größe der Textur kann das ganze durchaus ein paar Stunden dauern. Die Texturgröße geht stark in die Laufzeit ein, im Vergleich zum [[#Resynthesizer|Resynthesizer]] ist das Programm ziemlich langsam.

Als Inputdatei sollte man ein PNG wählen. Zum einen geht so keine Qualität verloren, zum anderen produziert das Programm aus irgendeinem Grund beim speichern von JPG Dateien einen schwarzen Balken am oberen Bildrand. Wenn man Probleme mit Rauschen im Ergebnis hat, kann man die Ausgabeauflösung etwas höher wählen und nachher das Bild herunter skalieren.

====Algorithmen====
MRFsynthesis implementiert verschiedene Variationen des Algorithmus. Die Unterschiede sind in der beiliegenden Readme beschrieben, verstehen tut man diese vermutlich aber nur nach der Lektüre des Papers, welches ich nicht gelesen habe.
*'''nonparaMRF''' : der Standardalgorithmus?
*'''nonparaMRF_fast''' : eine schnellere Version die einen QuadTree (?) verwendet
*'''nonparaMRF_fast_k''' : eine 2D-Variante von ''nonparaMRF_fast'', was immer das bedeutet...
*'''nonparaMRF_gaussian_k''' : verwendet eine "Gaussian pyramid" als Suchalgorithmus
Es hängt wahrscheinlich von der Quelltextur ab welcher Algorithmus sich am besten eignet. Einfach ausprobieren...

====Parameter====
Ein Beispielaufruf sieht so aus:
nonparaMRF_fast -n 2 -square -cyclic -x 1300 -y 1300 texinput1.png

Der Parameter '''-n''' ist der wichtigste, er gibt den Radius an in dem die Pixel verglichen werden. Möglich sind 1,2,3 und 4. Ein größerer Wert erfordert mehr Rechenleistung. Es hängt aber von der Struktur der Textur ab, ob man auch ein schöneres Ergebnis erhält. Man sollte mal 2 und 3 probieren. Der Parameter '''-square''' bewirkt das statt der üblichen 2-norm die Maximumdistanz verwendet wird. Was das heißt sieht man am besten auf dem folgenden Bild: 
[[Bild:neighbourhood.png]]

Der Parameter '''-cyclic''' bewirkt das die Textur kachelbar wird. Mit '''-x''' und '''-y''' gibt man die Größe der Outputtextur an.

Praktisch ist ebenfalls der '''-m''' Parameter. Damit kann man "doofe" Stellen in der Inputtextur ausblenden. Einfach die Quelltextur nehmen und mit schwarzer Farbe alles ausradieren was nicht gefällt. Alle Pixel die Farbe RGB 0,0,0 haben werden ignoriert. Sollten sich erwünschte Pixel mit dieser Farbe in der Textur befinden, sollte man vorher die Helligkeit der Masken-Textur erhöhen, z.B. indem man einen dunklen Grauwert aufaddiert. Auf das Ergebnis hat dies keinen Einfluss, da die eigentlichen Farbwerte aus der Inputtextur kommen.

Weitere Parameter sind in der beliegenden Readme beschrieben.

Für das erste Beispiel (siehe oben) habe ich die folgenden Parameter benutzt:
nonparaMRF_fast -n 2 -square -cyclic -x 1300 -y 1300 -m rock_mask.png rock_input.png
Das zweite Beispiel wurde mit folgender Befehlszeile berechnet:
nonparaMRF_fast -n 3 -square -cyclic -x 1300 -y 1300 -m earth_mask.png earth_input.png
Die Rechenzeit betrug auf meinem Intel Core 2 Quad Q9300 jeweils etwa 2-3 Stunden. Allerdings wurde natürlich nur ein Core genutzt und die CPU läuft bei mir zudem auf 2.0 GHz statt 2.5 GHz.

=== Resynthesizer ===
Der [http://www.logarithmic.net/pfh/resynthesizer Resynthesizer] ist ein Plugin für das beliebte Grafikprogramm [http://de.wikipedia.org/wiki/GIMP GIMP]. Sowohl GIMP als auch das Plugin sind freie Software, also insbesondere kostenlos und auch kommerziell nutzbar.

Von der Qualität her ist das Plugin mit [[#MRFsynthesis|MRFsynthesis]] vergleichbar. Durch die Integration in GIMP ist die Bedienung deutlich einfacher als über die Kommandozeile. Zudem hat Resynthesizer mehr Features und ist darüberhinaus wesentlich schneller. Da die Laufzeit weniger abhängig von der Texturgröße ist kann man mit wesentlich höheren Auflösungen arbeiten.

Auch der Resynthesizer setzt nur einen CPU-core ein und bei entsprechend hohen Auflösungen lohnt es sich mehrere Texturen gleichzeitig zu generieren. Wenn man es geschickt anstellt kann es auch sinnvoll sein mehrere Texturen zu generieren und dann nachträglich zusammenzufügen. Dies dürfte sich aber erst bei richtig hohen Auflösungen jenseits von 4096x4096 lohnen.

Die Bedienung ist recht simpel. Zunächst lädt man die gewünschte Quelltextur in GIMP und markiert dort alle Bereiche die man nicht für die Textur Generierung verwenden möchte. Man sollte daran denken, dass man die Kantenglättung der Markierung ausschaltet. Dann erstellt man ein neues Bild mit der gewünschten Auflösung und wählt im Menü
:<tt>Filter -> Abbilden -> Resynthesize...</tt>
Daraufhin öffnet sich das folgende Fenster.

[[Bild:resyn-options.jpg]]

Oben kann man die Texturquelle angeben, wir können aus den gerade mit GIMP geöffneten Bilddateien auswählen. Insbesondere kann auch die Quelle mit dem Ziel identisch sein. Die Haken bezüglich horizontalem und vertikalem Tiling sollten klar sein. Ist in der Zieltextur ein Bereich markiert, so bewirkt ein Haken bei ''"Fit output to bordering pixels"'', dass die neu erzeugte Textur nahtlos in den bereits bestehenden Bereich übergeht. Auch hier sollte man daran denken, dass man die Kantenglättung der Markierung ausschaltet.

[[Bild:resyn-tweaks.jpg]]

Hier kann man einige Parameter des Algorithmus beeinflussen. Es hängt von der Quelltextur ab welche Einstellung hier gut ist. Die Standardeinstellung erzeugt aber meistens bereits gute Resultate.

Das Plugin fügt auch noch ein paar Skripte zu GIMP hinzu die man mal austesten sollte:
:<tt>Script-Fu -> Enhance -> Smart enlarge</tt>
:: Bild skalieren ohne Schärfe zu verlieren
:<tt>Script-Fu -> Enhance -> Smart sharpen</tt>
:: Bild schärfen unter Einsatz von Textursynthese
:<tt>Script-Fu -> Enhance -> Smart remove selection</tt>
:: ersetzt den markierten Bereich durch eine synthetische Textur

== Perspektivenkorrektur ==
Als Abschluss möchte ich noch erwähnen, dass es mittlerweile auch eine stark verbesserte Implementierung des [http://www.graphics.rwth-aachen.de/ Lehrstuhls Informatik 8] der [http://www.rwth-aachen.de/ RWTH Aachen] die unter anderem eine Perspektivenkorrektur einsetzt. Dies ermöglicht es zu einem gewissen Grad auch die globale Struktur zu erhalten bzw. fortzusetzen. Zum Beispiel kann man das Colosseum in Rom virtuell wieder aufbauen. [http://www.graphics.rwth-aachen.de/index.php?id=33 Bilder und ein Video gibts hier]. Insbesondere das Bild des Aachener Rathauses ist heftig!

Tutorial OpenGL3

2014-03-09T11:06:48Z

Glawesome: /* Übersichten */ Kategorie hinzugefügt

=Vorwort=
Willkommen zur Einführung in OpenGL3.x.
Im Rahmen dieses Artikels werde ich versuchen, die Grundlagen für die Nutzung von OpenGL3 zu legen und durch Pseudocode die Verwendung von der [[OpenGL3.x_API|API]] aufzeigen. Mit OpenGL Version 3 hat sich vieles im Vergleich zu den Vorversionen verändert und entsprechend ist der Umstieg von OpenGL1-2 auf 3 sehr zeitaufwändig. Diese Artikelreihe richtet sich mehr an Anfänger als an Programmierer, die von der Vorversion umsteigen wollen.

==OpenGL3 und die Vorgeschichte==
OpenGL ist viele Jahre alt und entsprechend gab es immer wieder neue Versionen und Änderungen. Doch entfernte sich OpenGL mit der Zeit vom aktuellen Stand der Technik und veraltete immer mehr. Die API wurde größer und größer, alte nicht mehr gebrauchte Funktionen wurden aus Kompatibilitätsgründen nicht entfernt und die Treiber wuchsen zu riesigen und komplexen Codewerken. Darunter hat entsprechend die Leistung und Qualität stark gelitten. Es musste ein radikaler Schnitt gemacht werden und man beschloss, dies mit OpenGL Version 3 zu tun. So hat man sämtlichen Ballast von früher rausgestrichen und eine Hand voll neuer Funktionen hinzugefügt.

Um die Umstellung für Software leichter zu machen, beschloss man, zwei verschiedene Profile zu unterstützen. Das erste Profil ist ein OpenGL3-fähiger Grafikkontext, welcher auch die alten Befehle ausführen kann und somit die Umstellung schrittweise ermöglicht. Das zweite Profil ist ein OpenGL3-fähiger Grafikkontext, welcher nur die als nicht veraltet (deprecated) makierten Funktionen ausführen kann und für neue Software gedacht ist. Sollte man mit dem zweiten Profil arbeiten und ruft dennoch eine alte Funktion auf, dann wirft diese ein Fehler und wird nicht ausgeführt.

Mit den neuen Fähigkeiten der Grafikkarten entstanden parallel zu den OpenGL-Versionen auch Updates der Shadersprache GLSL. OpenGL verwendet Shader, um die Darstellung von 3D Modellen manipulieren zu können. So hat man anfangs mit Assembler ähnlichen Code und später mit C ähnlichen Code Mini-Programme geschrieben, welche auf dem Grafikprozessor lauffähig waren. Man hatte zwischen Vertex- und Fragment-Shadern/Programmen unterschieden. Mit dem Shader Model 4 kam eine weitere Shader-Kategorie hinzu, und zwar der Geometry-Shader. Während der Vertexshader einzelne Punkte eines Drahtgitters manipulieren konnte, hat der Fragment-Shader das Ausfüllen des Drahtgitters übernommen (shading) und die Geometry-Shader erlauben die Manipulation des Drahtgitters. Während Shader in OpenGL1-2 nicht notwendig waren, kann man in OpenGL3 nicht ohne auskommen, da ein Vertex-/Fragment-Shader zum Zeichnen benötigt wird.

Ein sehr beliebtes Werkzeug in OpenGL1-2, war der Immediate Mode, welcher das sehr einfache Zeichnen von 3D Daten erlaubte. Dieser wurde durch ein [[glBegin]] eingeleitet, ein glEnd beendet und alles was dazwischen stand wurde gezeichnet. Dies hatte allerdings auch seinen Preis: So war der Treibercode dadurch enorm komplexer geworden und es mussten aufgrund der vielen möglichen Variationen(gesetzte Flags) viele Prüfungen durchgeführt werden, um einen gültigen Rendercode zu erzeugen. Dieser wurde ebenfalls in OpenGL3 gestrichen und man muss nun sogenannte Vertex Buffer Objects (untermenge von Buffer Objects) verwenden. Diese haben den Vorteil, dass sie wesentlich schneller und ebenfalls recht einfach zu bedienen sind.

In OpenGL1-2 war es möglich, die Modelview- und Projection-Matrizen durch bestimmte API-Befehle zu manipulieren. Die Modelview-Matrix hat die Position eines Objektes so manipuliert, dass es den gewollten Platz in der 3D Welt eingenommen hat und die Projection-Matrix hat dann die 3D Weltkoordinaten auf 2D Bildschirmkoordinaten transformiert. Mit OpenGL3 sind ist diese Möglichkeit entfernt worden, da nun der Vertexshader diese Arbeit übernommen hat und diese Funktionalität mehr in den Anwendercode als in die Bibliothek gehört.

Die letzten 3 angesprochenen Punkte (Shader, Immediate Mode und Matrizen) haben großen Einfluss auf den Basis-Quellcode einer OpenGL3-Anwendung. Dieser fällt größer und umfangreicher aus, als ein Basis-Code für OpenGL1-2, wird aber später kaum größer aufgrund der Schlankheit der neuen API.

==Inhaltsverzeichnis==
===Grundlagen===
Artikel in diesem Bereich sind für OpenGL wichtig aber haben nicht direkt mit OpenGL zu tun.

Man kann diese Artikel überspringen und später bei aufkommenden Fragen in diese hinein lesen.

[[Tutorial_OpenGL3_Lineare_Algebra|Lineare Algebra]]
===Artikelreihe===
[[Tutorial_OpenGL3_dead|Vorschau auf das kommende]]

[[Tutorial_OpenGL3_Zeichenkontext|Erstellen eines Grafik Kontext]]

[[Tutorial_OpenGL3_Das_Objekt_System_von_OpenGL3|Das Objekt System von OpenGL3]]

[[Tutorial_OpenGL3_dead|Vertex Buffer Object]]

[[Tutorial_OpenGL3_dead|Verfügbare Geometrie]]

[[Tutorial_OpenGL3_dead|GLSLang]]

[[Tutorial_OpenGL3_dead|Geometryshader]]

[[Tutorial_OpenGL3_dead|Transform Feedback]]

[[Tutorial_OpenGL3_dead|Texturen]]

[[Tutorial_OpenGL3_dead|Frame Buffer Object]]

[[Tutorial_OpenGL3_Scissor_Clipping_DepthTest|Clipping/Scissor/Tiefen-Test]]

[[Tutorial_OpenGL3_dead|Instancing]]

[[Tutorial_OpenGL3_dead|Oclussion Query]]

[[Tutorial_OpenGL3_dead|Conditional Rendering]]

===Übersichten===
[[OpenGL3.x_API|OpenGL3-Funktionen nacht Kategorie sortiert]] 
[[OpenGL3-Funktionsübersicht|OpenGL3-Funktionen alphabetisch sortiert]]

[[Kategorie:Tutorial|OpenGL3]]

Tutorial OpenGL3 Zeichenkontext

2014-03-09T11:04:59Z

Glawesome: /* Erstellung eines OpenGL3.x GC */

==Der Grafikcontext==
Der Grafikcontext (GC) ist die Basis von OpenGL, man kann mehrere GCs in einem Prozess haben, was aber selten Sinn macht.
Im GC werden alle notwendigen Informationen gehalten, um mit der GPU zu arbeiten. Dabei werden Identifier (ID) verwendet, um Resourcen nach außen verfügbar zu machen. Zu solchen Ressourcen gehören z.B. Texturen, Shader, diverse Buffer Objects und alle werden durch IDs zur Verfügung gestellt.
Neben den ID-Listen werden noch sogenannte States, Informationen für die Bildausgabe und diverse unbekannte treiberspezifische Daten gespeichert.

===Profil===
Um die einzelnen Befehlssätze zu verwalten, hat man sogenannte Profile eingeführt.
OpenGL3 ist z.B. ein Profil, es gibt noch weitere wie z.B. OpenGL3.1 oder OpenGL3.1 Debug.
Die Profile werden vom ARB festgelegt und es gibt in der Regel 2 Versionen: Einmal mit Funktionen, die als "deprecated" eingestuft wurden, und einmal ohne diese.

===Forward compatible context und Full context===
Es gibt 2 Varianten eines Context, der ''Full context'' enthält alle Funktionen, auch die als deprecated markierten. Der ''Forward compatible context'' enthält nur die nicht als deprecated markierten Funktionen des OpenGL-Kerns. Bis zur Version 3.1 gab es immer eine Abwärtskompatibilität und der Treiber hatte entschieden, welche OpenGL-Version verwendet werden darf. Mit OpenGL 3.1 gibt es keine Abwärtskompatibilität mehr und man kann festlegen, was für einen GC man haben möchte.

===Verwaltung der veralteten und neuen Funktionen===
Das Hinzukommen und das Entfernen von OpenGL-Funktionen unterliegt dem Deprecation- und Extension-Mechanismus.
Diese funktionieren wie folgt.

'''Deprecation Path''': Core->ARB->Vendor/Extension

Die Funktion wird erst aus den Bereich der Kernfunktionen entfernt und als ARB zur Verfügung gestellt.
Dann wird sie aus dem ARB entfernt und als Vendor oder Extension weiter geführt.
Der Kern wird von der Khronos Group verwaltet, das ARB wird von einer Gruppe bestehend aus AMD/ATI, Nvidia, SGI, Sun, Intel, IBM, Apple, 3DLabs und einigen weiteren zusammen verwaltet und Vendor sowie Extension werden von Firmen wie AMD, Nvidia, SIS und so weiter einzeln verwaltet.

'''Extension Path''': Vendor/Extension->ARB->Core

Wenn eine Extension von einer Firma, vom ARB als sinnvoll angesehen wird, dann wird diese mit aufgenommen.
Funktionen, die vom ARB aufgenommen wurden, werden in der Regel mit der kommenden OpenGL-Version in den Kern aufgenommen.

OpenGL3 macht regen Gebrauch von diesen Mechanismen, da viele Kernfunktionen als deprecated markiert wurden und nun über die einzelnen Updates aus dem Kern verschwinden. Da sich der Stand der Technik weiterentwickelt kommen natürlich auch neue Funktionalitäten hinzu, so z.B. [[Transform-Feedback]], [[Instancing]] oder GLSlang 1.4.

=Der erste Schritt (OpenGL Context)=
Als erstes wird ein Fenster benötigt, um an dieses unseren GC zu binden. Ich will nicht näher auf die Erstellung eines Fensters eingehen, da dies nicht das Thema dieses Artikels ist und verweise auf den Democode am Ende des Artikels. Sobald das Fenster erstellt ist, können wir uns darum kümmern, einen passenden GC zu erstellen. Hierzu brauchen wir erstmal Informationen vom Desktop Manager, welche Möglichkeiten wir überhaupt zur Auswahl haben. Es wird ein [[Doppelpufferung|Double Buffer]] benötigt und man muss die Farbtiefe sowie Genauigkeit des [[Tiefenpuffer]]s festlegen. Dies wird von den Desktop Managern unterschiedlich gehandhabt, so hat Windows z.B. ein DeviceContext und ein Pixelformat und X11 nennt dies VisualInfo bzw. GLXFBConfig.
Ist dieser Schritt getan, kann man nun einen alten OpenGL Context erstellen, prüfen ob die ARB Funktion vorhanden ist und dann versuchen einen OpenGL3.x Context zu erstellen.

==Erstellung eines OpenGL3.x GC==
Um einen GC ertellen zu können, wird eine weitere API benötigt, welche plattformabhängig und durch wgl[Funktionsname]/glX[Funktionsname] erkennbar ist. Mit diesen Befehlen kann man mit dem Windows und X11 Desktop Manager zusammenarbeiten. So werden Funktionen für das Erstellen, Wechseln, Zerstören eines GC, Laden von Extensions, Wechseln des Fensterpuffers und Synchronisieren von CPU und GPU ermöglicht. Bisher gibt es noch keine Möglichkeit, einen OpenGL3-fähigen GC zu erstellen, ohne dafür eine Funktion vom ARB zu verwenden. Der Nachteil von ARB-Funktionen ist, dass man einen gültigen GC benötigt, um den Zeiger auf diese zu erhalten. Um einen OpenGL 3.0 oder 3.1 GC zu erstellen, benötigt man einen OpenGL1-2 GC und die Kernfunktion [[wglGetProcAddress]]/[[glxGetProcAddress]]. Einen gültigen OpenGL1 bzw. OpenGL2 GC bekommt man über den Befehl [[wglCreateContext]]/[[glxCreateContext]] und zwischen mehreren GC kann man mit dem Befehl [[wglMakeCurrent]]/[[glxMakeCurrent]] wechseln.
Der Befehl für die Erstellung eines OpenGL3-fähigen GC heißt [[wglCreateContextAttribsARB]]/[[glxCreateContextAttribsARB]].
Mit OpenGL3.2 soll eine Funktion in den OpenGL-Kern kommen, welcher es erlaubt einen OpenGL3 und aufwärts fähigen GC zu erstellen, ohne einen älteren GC vorher zu erstellen. Dies wird erreicht, indem man die noch jetzige ARB Funktion in den OpenGL-Kern mit aufnimmt und somit das Erfragen der ARB Funktion, über ein OpenGL1-2GC, unnötig macht.

'''Windows'''
<source lang="cpp">void CreateOpenGL3Context()
{
HGLRC TempContext=wglCreateContext(DeviceContext);//erstellt ein alten OpenGL Context
if (TempContext==NULL)
{
cerr<<"Error: Could not create an OpenGL rendering context"<<endl;
return;//beenden
}
wglMakeCurrent(DeviceContext,TempContext);//setzt den erstellten GC als aktuellen GC

//Typdefinition von wglCreateContextAttribsARB
typedef HGLRC (APIENTRY * PFNWGLCREATECONTEXTATTRIBSARBPROC)(HDC hDC, HGLRC hShareContext, const int *attribList);

PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribsARB = NULL;

//abfragen, ob die Funktion existiert
wglCreateContextAttribsARB=(PFNWGLCREATECONTEXTATTRIBSARBPROC)wglGetProcAddress("wglCreateContextAttribsARB");

if(wglCreateContextAttribsARB == NULL)//wenn es diese Funktion nicht gibt, dann hat der -->Treiber<-- keinen OpenGL3 support
{
wglDeleteContext(TempContext);
cerr<<"Error: There is no OpenGL3 context support."<<endl;
return;
}

int attribs[]={WGL_CONTEXT_MAJOR_VERSION_ARB,3,WGL_CONTEXT_MINOR_VERSION_ARB,1,WGL_CONTEXT_FLAGS_ARB,WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,0};

if (!(Context=wglCreateContextAttribsARB(DeviceContext,0, attribs)))//versuche ein OpenGL3.1 fähigen Context zu erstellen
{
//Entweder hat der Treiber noch keinen OpenGL3.1 support oder die Grafikkarte beherrscht kein OpenGL3.1.
cerr<<"Error: Couldn't create OpenGL3.1 context. Try now OpenGL3.0 context"<<endl;
return;

attribs[3]=0;//Setze minor version auf 0 um ein OpenGL3.0 context zu erstellen.
if (!(Context=wglCreateContextAttribsARB(Win->GetDeviceContext(),0, attribs)))
{
//Die -->Grafikkarte<-- beherrscht kein OpenGL3.
wglDeleteContext(TempContext);//aufräumen und beenden
cerr<<"Error: Couldn't create OpenGL3 context."<<endl;
return;
}
}
wglMakeCurrent(DeviceContext,Context);//wechsel auf den OpenGL3.x context
wglDeleteContext(TempContext);//Zerstöre den temporären Context, denn er wird nicht länger benötigt.
}</source>

Mac OS erlaubt die nachträgliche Installation von X11 und kann somit über den folgenden Code ebenfalls einen OpenGL Context erstellen. Alternativ bietet Mac OS mehrere OpenGL Schnittstellen, welche sich in der Einfachheit der API unterscheiden. Wenn man nicht den Nutzer zwingen will X11 zu installieren, dann sollte man zu den entsprechenden Schnittstellen AGL, CGL oder NSOpenGL greifen.

'''X11(Linux/Mac OS)'''
<source lang="cpp"> bool OpenGLWindow::CreateOpenGL3Context()
{
GLXContext TempContext=glXCreateContext(m_Display,m_VisualInfo,0,GL_TRUE);//erstellt ein alten OpenGL Context
if(TempContext==0)
{
cerr<<"Error: Could not create an OpenGL rendering context."<<endl;
return false;
}
glXMakeCurrent(m_Display,m_Window,TempContext);

//Typdefinition von wglCreateContextAttribsARB
typedef GLXContext (* GLXCREATECONTEXTATTRIBSARBPROC)(Display *dpy,GLXFBConfig config,GLXContext share_context,Bool direct,const int *attrib_list);
//abfragen, ob die Funktion existiert
GLXCREATECONTEXTATTRIBSARBPROC glXCreateContextAttribsARB = (GLXCREATECONTEXTATTRIBSARBPROC)glXGetProcAddress((const GLubyte*)"glXCreateContextAttribsARB");

if(glXCreateContextAttribsARB == NULL)//wenn es diese Funktion nicht gibt, dann hat der -->Treiber<-- keinen OpenGL3 support
{
cerr<<"Error: There is no OpenGL3 context support."<<endl;
return false;
}
int minor=0;
int major=0;
glGetIntegerv(GL_MAJOR_VERSION,&major);
glGetIntegerv(GL_MINOR_VERSION,&minor);
int attribs[]={GLX_CONTEXT_MAJOR_VERSION_ARB,major,GLX_CONTEXT_MINOR_VERSION_ARB,minor,GLX_CONTEXT_FLAGS_ARB,GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,0};
for (int i=minor; i>=0;i--)
{
attribs[3]=i;//Setze minor version auf 0 um ein OpenGL3.0 context zu erstellen.
m_Context=glXCreateContextAttribsARB(m_Display, m_FBConfig[0], NULL, true, attribs);
if (!m_Context)//versuche ein OpenGL3.i fähigen Context zu erstellen
{
if (i>0)
{
//Entweder hat der Treiber noch keinen OpenGL3.i support oder die Grafikkarte beherrscht kein OpenGL3.i.
cerr<<"Error: Couldn't create OpenGL3."<<i<<" context. Try now OpenGL3."<<i-1<<" context"<<endl;
continue;
}
else
{
//Die -->Grafikkarte<-- beherrscht kein OpenGL3.
glXDestroyContext(m_Display,TempContext);//aufräumen und beenden
cerr<<"Error: Couldn't create OpenGL3 context."<<endl;
return false;
}
}
break;
}
glXMakeCurrent(m_Display,m_Window,m_Context);//wechsel auf den OpenGL3.x context
glXDestroyContext(m_Display,TempContext);
return true;
}
}</source>

[[Kategorie:Tutorial|OpenGL3 Zeichenkontext]]

Tutorial Raytracing - Grundlagen I

2014-03-09T11:01:09Z

Glawesome: /* Vorschau */ Kategorie hinzugefügt

= Tutorial Raytracing - Grundlagen I =
[[Bild:Tutorial_RaytracingI_teaser.jpg|center]]
== Einführung ==
Da melde ich mich mal wieder zurück mit einem kleinen Tutorial bezüglich Raytracing. Ihr sollt ja gelegentlich was neues lernen. Es ist zwar etwas schade, dass nur noch selten Tutorials aus der Community kommen - ich hoffe immer noch, dass sich das irgendwann wieder ändern wird. Und alle die bislang Tutorials geschrieben haben, mussten ja irgendwann ihr erstes schreiben - also nur Mut (mein allererstes war im Übrigen das 1. Tutorial aus der Terrain-Reihe). Nunja. Was hat es also mit dem Raytracing auf sich? Und warum heißt dieses Tutorial Grundlagen I? Ich will es euch erklären. Beim Raytracing verfolgt man im Gegensatz zum Rastern wie es etwa OpenGL oder Direct3D machen, einen anderen Ansatz. Statt Objekte oberflächlich in Polygone zu zerschneiden und sie dann auf den Bildschirm per Z-Buffer zu projizieren, wirft die Kamera Strahlen in die Szenerie und auf jedem Strahl prüft man, ob sich ein Objekt mit dem Strahl schneidet. Man verliert dadurch sehr deutlich Geschwindigkeit: die wenigsten Raytracer sind so schnell, dass man interaktiv damit arbeiten kann. Wozu also ist dann Raytracing gut? Man kann im Raytracer hoch realistisch wirkende Bilder erzeugen und auch Verfahren verwenden, die im Rasterizer nicht oder kaum nachzubauen sind - die gute alte Grafikkarte muss dabei nicht völlig unnütz werden: Diese besitzen sehr flotte und massiv parallele Geometrie-Einheiten, die auch im Raytracer Verwendung finden können - dies ist aber etwas zu speziell für unser kleines Tutorial und vielleicht auch nicht das, was man in seinem ersten Raytracer implementieren würde. Was sich im Bereich interaktiver Grafik allerdings anbietet, ist den Raytracer ein wenig umzumodeln und mit ihm statische Lightmaps erzeugen oder ihn zur Selection missbrauchen. Das einzige Problem welches wir dabei haben: Wir müssen alles von Grund auf zusammenbasteln - nicht so schön, wie bei OpenGL, wo man nach ein paar Stunden recht ansehnliche Bilder samt Beleuchtung zeichnen kann. Wir werden da wohl etwas länger brauchen, aber ewig wird es auch nicht dauern - und schliesslich musste OpenGL ja auch erst einmal designed werden. Andere Dinge werden sich dagegen deutlich leichter implementieren lassen als mit OpenGL, so sind etwa Schatten im Raytracer ein Kinderspiel - im Rasterizer können sie richtig arbeitsintensiv werden.

== Die griechische Vorstellung ==
[[Bild:Tutorial_RaytracingI_griechisch.jpg|right]]
Die Griechen hatten eine etwas sonderbare Vorstellung vom Sehen: Sie stellten sich vor, dass aus ihren Augen Strahlen kommen, die dann auf die Umgebung treffen und quasi Nachricht an das Auge geben, was sie getroffen haben, wie weit weg es ist und welche Farbe es hat. Das ist in etwa das was auch ein Raytracer macht. Wir wollen das erst einmal im Hinterkopf behalten und uns zunächst mit Strahlen genauer auseinandersetzen. Danach werden wir Kugeln mit diesen Strahlen schneiden und eine passende perspektivische Kamera entwerfen. Schließlich werden wir einen sehr einfachen Raytracer schreiben, und ihm anschließend noch Ebenen als Objekte näherbringen, weil Kugeln alleine doch etwas langweilig sind.

== Strahlen ==
Was ist also ein Strahl? Ein Strahl hat einen Ursprung, an dem er beginnt, und eine Richung, in die er verläuft. Wer in der Schule in Geometrie aufgepasst hat, kennt dieses Objekt sicher auch noch als Halbgerade. Da wir später damit rechnen werden, müssen wir den Strahl in eine schöne Formel packen:
[[Bild:Tutorial_RaytracingI_strahlgleichung.png|center]]
Die Punkte auf unserem Strahl r sind also parametrisiert durch t, welches die
Zahlen von 0 bis unendlich durchläuft. Der Ursprung des Strahles ist o und seine
Richung d. Somit kennen wir alle Punkte auf dem Strahl.

Um nun zu prüfen, ob ein Strahl nun ein Objekt trifft, beginnen wir bei t = 0 und laufen alle Punkte ab, bis wir bei t = unendlich angekommen ... ... ... Nein so machen wir das natürlich nicht - funktionieren würde es zwar, würde aber unendlich lange dauern: Nicht gerade das, was wir uns unter schnell vorstellen.

Bevor wir weitermachen, sollten wir unseren Strahl gleich in
etwas Code verpacken, schließlich wollen wir uns ja einen Raytracer schreiben:
<source lang="cpp">public struct Ray
{
public Vertex3 Origin;
public Vertex3 Direction;

public Vertex3 Evaluate (double t)
{
return Origin + t * Direction;
}
}</source>

Zurück zu unserem Problem: Wir müssten also unendlich lange darauf warten, bis unser Raytracer das Objekt gefunden hat, mit dem sich der momentan betrachtete Strahl schneidet. Viel schneller geht die Sache, wenn wir vorher beschließen, welche Objekte wir anzeigen können wollen. Für den Anfang wollen wir uns mit sehr einfachen Objekten begnügen: Kugeln. Sie sind schnell berechnet und werden für erste Experimente ausreichen.

== Kugeln ==
Erinnerung: Eine Kugel ist definiert durch ihren Mittelpunkt und ihren Radius r. Setzt man den Mittelpunkt auf den Ursprung des Koordinatensystems, dann sind die Punkte auf der Oberfläche O unserer Kugel gerade die Punkte, die vom Ursprung den Abstand r haben. Die uns interessierende Bedingung wird so zu ||p|| = r für Punkte p auf O. Die Gleichung kann man schadlos quadrieren und statt der Vektorlänge ||p|| bekommt man das ohne Wurzel ziehen zu berechnende [[Standard Skalarprodukt|Skalarprodukt]] von p mit sich selbst:
[[Bild:Tutorial_RaytracingI_skalprodpp.png|center]]
Setzt man hierein die obige Gleichung für den Strahl, ergibt sich:
[[Bild:Tutorial_RaytracingI_radsqr.png|center]]
Und damit:
[[Bild:Tutorial_RaytracingI_radsqr2.png|center]]
Da die Richtung o und d unseres Strahls bekannt sind, haben wir eine quadratische Gleichung vor der Nase, die wir mittels Mitternachtsformel lösen können:
[[Bild:Tutorial_RaytracingI_mitternacht.png|center]]
Anhand der Diskriminante D, also dem Teil des obigen Ausdrucks, der unter der Wurzel steht, können wir entscheiden, ob der Strahl die Kugel trift. Ist nämlich D < 0, so kann man in den reelen Zahlen die Wurzel nicht berechnen. Ist D = 0, so gibt es genau eine Lösung der Schnittgleichung und für D > 0 schneidet der Strahl die Kugel genau 2 mal. Da wir unseren Strahl nur für positive Parameter t definiert haben, sollten wir die errechneten Schnittpunkte t1 und t2 noch daraufhin untersuchen:
<source lang="cpp">public double RayIntersect ( Ray ray )
{
double boundingSquare = sphereRadius * sphereRadius ;
ray.Origin -= Position;
double a, b, c;
a = ray.Direction.DotDot ;
// DotDot ^= Skalarprod mit sichselbst : <d, d>
b = 2 * ( ray.Origin * ray.Direction );
// * ^= normales Skalarprod
c = ray.Origin.DotDot - boundingSquare;

double t1 , t2 ;
int roots = CalcQuadricRoots (a, b, c, out t1, out t2) ;

if (roots > 0)
return t1 >= 0 ? t1 : t2 ;
// kleinsterpositiver pos. Wert aus t1, t2
else
return -1; // Kein Schnittpunkt
}</source>
Einen kleinen Haken hat die Sache jedoch: Analytisch, d.h. per Stift und Papier, lässt sich mit der Mitternachtsformel wunderbar rechnen. Am Computer neigt sie zu Fehlern, was ganz allein an dem ± liegt. So führt man verlässlich eine Subtraktion durch, wenn D > 0 ist - und Subtraktionen sind reines Gift für die Genauigkeit bei numerischen Rechnungen. Durch kleine Umformungen und das Bestimmen eines Vorzeichens, können wir das Problem umgehen:

== Quadratische Gleichungen ==
Hat man also eine Quadratische Gleichung in der allgemeinen Form:
[[Bild:Tutorial_RaytracingI_quadratisch.png|center]]
dann bestimmt man die Nullstellen am besten durch:
[[Bild:Tutorial_RaytracingI_quadratisch_numerisch.png|center]]
Bei der Auswertung von q wird so sicherlich echt addiert, weil zu b eine Zahl gleichen Vorzeichens summiert wird. Dass der Wert für t1 stimmt, hat man dann auch sehr leicht nachgerechnet, wohingegen t2 in wildes Rumgeschiebe der Formel ausartet und sich erst recht spät sign(b) herauswerfen lässt. Ich erspare euch nähere Erläuterungen ;-) Ein bisschen Quellcode hierzu:

<source lang="cpp">public static int CalcQuadricRoots(double a, double b, double c, out double x1, out double x2)
{
double determinant = b * b - 4 * a * c;
if (determinant < 0)
{
x1 = 0.0;
x2 = 0.0;
return 0;
}
determinant = Math.Sqrt(determinant);
double q = -0.5 * (b + PSgn(b) * determinant);
// Psgn: gives - 1 if b < 0 and 1 if b >= 0.
// so no zero as normal sgn would give us.
x1 = q / a;
x2 = c / q;
// Sort by value
if (x1 > x2)
{
q = x2; x2 = x1; x1 = q;
}
return x1 == x2 ? 1 : 2;
}</source>
Die Funktion speichert die Nullstellen in den Variablen x1, x2 dem Wert nach sortiert ab und gibt die Anzahl der Nullstellen zurück.
Da wir jetzt bereits bestimmen können, wo und wie oft unser Strahl die Kugel trift, können wir, nachdem wir uns noch einen Strahlenwerfer, (also eine Kamera) konstruiert haben, unseren ersten Raytracer bauen.

== Perspektivische Kamera ==
Jeder, der sich mit OpenGL auskennt, wird bei der Konstruktion einer perspektivischen Kamera gleich schreien, dass man dazu doch einfach nur eine Projektionsmatrix braucht, die man sich ganz einfach aus der OpenGL Spezifikation stibitzen kann. Falsch gedacht: Ein Raytracer ist kein Rasterizer: Wir brauchen keine Projektionsmatrizen, noch nicht einmal Matrizen. Die perspektivische Kamera eines Ray-Tracers lässt sich direkt nach vorn heraus entwerfen:

[[Bild:Tutorial_RaytracingI_perspektivisch.png|center]]

Unrotiert und unverschoben soll unsere Kamera in die Tiefenrichtung z blicken. Dabei wird unser Bildschirm durch die Parameter links, rechts, oben und unten beschrieben. Ist die Auflösung des Bildschirms in X wie in Y-Richtung bekannt, so kann man leicht die Richtung d des Vektors bestimmen, der vom Betrachter auf den Bildschirm zeigt. Sofort bekommt man so einen Strahl, wenn man als Anfangspunkt o die Position des Betrachters wählt:

<source lang="cpp">public Ray ShootRay ( int x , int y )
{
Ray result = new Ray();
result.Origin = Position;

double xpart , ypart ;
xpart = ( ( double ) x ) / (double ) widthpixels;
ypart = ( ( double ) y ) / (double ) heightpixels;

xpart = left + xpart * ( right - left ) ;
ypart = top + ypart * ( bottom - top ) ;

result.Direction.x = xpart;
result.Direction.y = ypart;
result.Direction.z = 1.0;

/* if ( Transformation != null )
{
result.Direction =
Transformation.Apply( result.Direction );
} */
result.Direction.Normalize();
return result;
}</source>
Die auskommentierte if-Abfrage soll vorerst nicht stören. Ihr wird später leben eingehaucht, wenn wir dem Raytracer Verschiebungen,
Rotationen, Skalierungen, Scheerungen, u.s.w. einbauen.

== Einfacher Raycaster ==
[[Bild:Tutorial_RaytracingI_depthcasting.jpg|right]]
Damit sind wir dann auch schon soweit, dass wir unsere ersten Gehversuche in Sachen Raytracing wagen können. Für jedes Pixel im Bild werfen wir mittels ShootRay einen Strahl und prüfen, ob dieser die Kugeln in unserer Szene schneidet. Wenn ja, merken wir uns den nähestes dieser Schnittpunkte und weisen ihm einen Farbwert zu. So erhalten wir ein Bild, das in etwa die Informationen wieder gibt, die OpenGl in seinem Tiefenpuffer speichern würde. Ich gebe zu, das ist nicht hochgradig spannend, aber solange wir uns noch nicht eingehender mit Licht und Shading beschäftigt haben, können wir auch nicht mehr erwarten - und wir haben beim Raytracing ja leider das Problem, dass wir ganz von vorne anfangen müssen:

<source lang="cpp">public RaytraceImage ( int width , int height )
{
// near und far sind die Werte fuer den Bereich ,
// von dem Tiefeninformationen abgebildet werden
for ( int x = 0; x < width; x++) {
for ( int y = 0 ; y < height; y++) {
Ray shoot = ShootRay (x , y);
double maxdist = double.Infinity;

foreach (Kugel obj in SichtbareKugeln) {
double hitdist = obj.RayIntersect(shoot) ;
if (hitdist > 0 && maxdist > hitdist)
maxdist = hitdist;
}

if (maxdist < double.Infinity) {
SetColor(x, y, Colors.Gray (Math.Min(Math .Max(0,
(maxdist - near) / ( near - far ))), 1.0)) ;
}
else
SetColor(x, y, BackgroundColor);
}
}
}</source>
Eine kleine Anmerkung noch: Da wir uns noch nicht über Transformationen Gedanken gemacht haben, und unsere Kugeln bislang am Nullpunkt aufgehäng sind, können wir diese noch nicht positionieren - sprich es wird höchstens die größte Kugel sichtbar, weil alle weiteren verdeckt sind. Das lässt sich beheben, indem man vor dem Test auf Schnitt vom Ursprung des entsprechenden Strahles, die Position der Kugel abzieht.

== Ebenen ==
Mit Kugeln kann man zwar so einiges darstellen, aber nur Kugeln sind vielleicht doch etwas langweilig. Wir wollen deshalb noch Ebenen implementieren. Am besten betrachten wir diese dazu in der Normalform, d.h. die Ebene wird allein durch ihre Flächennormale angegeben. Für Punkte auf der Ebene gilt dann:
[[Bild:Tutorial_RaytracingI_ebenengleichung.png|center]]
Setzt man nun in x unseren Strahl ein, ergibt sich:
[[Bild:Tutorial_RaytracingI_ebenenrechnung.png|center]]
Ist <d,n>=0, dann gibt es keine Lösung, sonst genau eine.

Welche Objekte eignen sich sonst gut zum Raytracing? ... Alle Objekte, die sich in kartesischen Koordinaten durch eine Gleichung der Form [[Bild:Tutorial_RaytracingI_kartesisch.png|center]] darstellen lassen. In (x,y,z) setzt man seinen Strahl r(t) ein und versucht nach t aufzulösen. In einigen Fällen wird dieses Problem leider kaum zu lösen sein: man kommt dann um den Einsatz von numerischen Verfahren nicht herum. Ich werde versuchen, in Folgetutorials noch ein paar weitere, interessante Objekte vorzustellen, die sich direkt lösen lassen und wenn ich viel Geduld habe, vielleicht auch einmal einen eigenen Artikel bezüglich numerischer Verfahren.

== Vorschau ==
Damit sind wir auch schon wieder soweit. Die ersten Grundlagen sind abgehandelt, aber wirklich überzeugt sind wir vom Raytracing noch nicht. Damit sich das ändert, sind weitere Tutorials in Planung: Wir wollen uns dann mit Licht und Normalen beschäftigen. Außerdem sind Reflektionen und Transparenz spannende Dinge, denen wir uns widmen können. Wir wollen außerdem unsere Objekte transformieren, scheeren, rotieren, ... Es bleibt also noch einiges im Bereich Raytracing zu tun, was hier nicht behandelt wurde.

Bis es soweit ist, könnt ihr euch ja selbst schonmal ein paar Gedanken zum Thema machen oder euch doch lieber in die Weiten von OpenGl flüchten.

'''Delphic'''

[[Kategorie:Tutorial|Raytracing - Grundlagen I]]

Tutorial Raytracing - Grundlagen II

2014-03-09T11:00:20Z

Glawesome: /* Abschluss */ Kategorie hinzugefügt

= Raytracing Grundlagen II =
[[Bild:Tutorial_RaytracingI_teaser.jpg|center]]
== Einführung ==
Und weiter geht es mit unsem Raytracing Tutorial. Wir wollen unseren Raytracer nun langsam aber sicher soweit bekommen, dass sich damit etwas ansehnlichere Bilder erzeugen lassen. Wer das [[Tutorial_Raytracing_-_Grundlagen_I|vorangehende Tutorial]] nicht gelesen hat, sollte dies am besten gleich tun - ich will ja nicht alles neu erklären. Womit werden wir uns denn heute beschäftigen? Zuerst werden wir ein erweiterbares Objektmodell für alle Objekte planen und überlegen. Dann wollen wir uns ein wenig mit Phong-Lighting beschäftigen und einige Gedanken in Richtung Transformationen verschwenden. Mit diesem Plan sind wir, so denke ich, erstmal gut beschäftigt.

== Ein schönes Basisobjekt ==
Wir wollen die Objekte in unsem Raytracer möglichst gleich behandeln können, so dass der eigentliche Raytracing Algorithmus ohne jegliches wissen über die Struktur der Objekte arbeiten kann. Sprich: Wir definieren ein Basisobjekt, von dem anschließend alle weiteren Objekte abgeleitet werden. Was also soll dieses Objekt an Methoden und Eigenschaften zur Verfügung stellen? Jedes Objekt hat sicherlich eine Position, sowie gewissen Materialeigenschaften, die dem Objekt zugewiesen werden. Auch soll das Objekt sauber mit Transformationen umgehen können. Und was natürlich ganz wichtig ist: Wir brauchen eine Methode die prüft, ob sich das Objekt mit dem Strahl schneidet. Über einige dieser Dinge haben wir uns noch keine Gedanken gemacht, entsprechend sollen hierfür nur leere Dummyklassen und Methoden zum Einsatz kommen, die wir erst später realisieren. Damit es nicht vergessen wird: Es ist auch sinnvoll Vater-Kindbeziehungen zu haben um später zusammengesetzte Objekte definieren zu können. Das klingt alles etwas wild, artet in einer großen Menge Code aus, ist aber eigentlich gar nicht so schlimm, wei es sich anhört:

<source lang="cpp"> /// General Raytracing object in a tracer. All traceable objects must be derivates
public abstract class ObjectBase
{
#region Positioning Variables

private Vertex3 pos = new Vertex3();
/// The Position of the Object in parental Space
public Vertex3 Position
{
get { return pos; }
set { pos = value; /*InvalidateBoundings(true);*/ }
// Anm.: InvalidateBoundings brauchen wir jetzt noch
// nicht. Wenn man allerdings mit Bounding-Volumes
// zu arbeiten beginnt, wird man entsprechende
// Funktionalität benötigen. Vorerst gilt: Forget it.
}

private ILinearTransformation ptransformation;
/// The Transformation applied to the object
public ILinearTransformation Transformation
{
get
{
return ptransformation;
}
set
{
ptransformation = value;
//InvalidateBoundigs(true);
}
}
#endregion

#region Material
private Material objMaterial = new StandardMaterial();
/// Material assigned to object
public Material ObjectMaterial
{
...
}
#endregion

#region Parenting
// The parental object
private ObjectBase fParent;

/// The Parent of the object
public ObjectBase Parent
{
...
}
#endregion

#region Trans Space Functions
public virtual Vertex3 TransSpaceWorldToObject(Vertex3 v) {...}
public virtual Ray TransSpaceWorldToObject(Ray r) {...}
public virtual Vertex3 TransSpacePointWorldToObject(Vertex3 v) {...}
public virtual Vertex3 TransSpacePointParentToObject(Vertex3 v) {...}
public virtual Ray TransSpaceParentToObject(Ray r)
{
Ray ray = r;
ray.o -= pos;
return ray;
}
public virtual Vertex3 TransSpaceParentToObject(Vertex3 v) {...}
public virtual Vertex3 TransSpaceObjectToWorld(Vertex3 v) {...}
public virtual Vertex3 TransSpacePointObjectToWorld(Vertex3 v) {...}
#endregion

#region Intersection Tests
/// Calculates the first visible intersection. Returns values smaller
/// equal zero if there is no intersection.
/// param name="rs": Global rendersettings
/// param name="ray": the ray to test for intersection
/// param name="raymindist":
/// param name="raymaxdist":
/// param name="calcNormals":
/// param name="calcTextureCoordinates":
/// param name="info":
public abstract int Intersect(RenderSettings rs, Ray ray, double raymindist, double raymaxdist,
bool calcNormals, bool calcTextureCoordinates, ref IntersectionInfo info);
#endregion
}
</source>
Das schaut jetzt tatsächlich etwas wild aus, aber keine Angst. Wir werden das alles der Reihe nach mit Leben füllen. Die Trans-Space-Funktionen werden wir anschließend mit Leben füllen - nur TransSpaceParentToObject kann gleich bestückt werden (wir werden das aber später erweitern müssen). Sie soll Strahlen aus dem Eltern-Raum in den lokalen Raum überführen - für die meisten Objekte bedeutet dies: Die globalen Koordinaten werden in lokale übersetzt, so dass sich unser Objekt genau im Zentrum des Geschehens, d.h. bei (0,0,0), befindet und wir uns dann nie wieder über die Position des Objektes Gedanken machen müssen.

Einen Blick sind auch die Parameter von Intersect wert. rs beschreibt globale Einstellungen des Renderers. Darin könnte man z.B. festlegen, ob Schatten berechnet werden sollen oder nicht. Ihr könnt hier im wesentlichen spazieren führen was ihr wollt, aber diese Option zu haben ist jedenfalls nicht verkehrt. ray dürfte klar sein.
Dies wird ein Strahl sein, der jeweils in elterlichen Koordinaten gegeben ist, also mithilfe von TransSpaceParentToObject in lokale Koordinaten umgerechnet werden kann. raymindist und raymaxdist beschreiben jeweils Bereich des Strahles, in dem wir nach Überschneidungen suchen sollen - haben wir es mit einem numerisch zu berechnenden Objekt zu tun, kann diese Information bereits sehr viel Geschwindigkeit ausmachen. Beim Schnitt mit Kugeln ist die Sache dagegen weniger wichtig. Essenziell ist, dass beim Aufruf von Intersect sichergestellt sein muss, dass nur dann positive Rückmeldung gemacht wird, wenn die Überschneidung an einer Stelle des Strahles zu finden ist, die größer gleich raymindist ist: Darauf sollte man sich verlassen können. calcNormals und calcTextureCoordinates beschreibt, ob beim Überschneidungstest Informationen über Flächennormalen bzw. Texturkoordinaten erzeugt werden sollen: Bei manchen Objekten ist auch diese Information nur kostspielig zu bekommen und wir wollen es deshalb optional halten. Es bleibt noch der Call by Reference Parameter info. Darin sollen genauere Informationen bezüglich des Schnittes gespeichert werden - etwa lokale Farben, Material, Texturkoordinaten, Schnittposition, etc. (Die Schnittposition könnte man auch direkt zurückgeben, also den Rückgabewert durch einen Float-Typ wie double ersetzen. Seis drum)

Noch schnell ein kleiner Blick in eine mögliche Definition der IntersectionInfo. Darin befindet sich nichts anderes, als wie das, was ich gerade beschrieben habe. Also keine Überraschungen ;-)

<source lang="cpp"> public struct IntersectionInfo
{
/// Position on ray where the cut occured
public double rayPosition;
/// Normal of surface at cut position
public Vertex3 normal;
/// Texture coordinates
public Vertex3 texture;
/// Material of surface at intersection position
public Material material;
/// The local color of the intersection. This must be optional
/// for all materials!!! Some Objects may always return black here.
public Color localColor;
}
</source>

== Transformationen ==
Wir wollen uns nun um Transformationen kümmern. Was also sind Transformationen? Wer mit OpenGl vertraut ist, kennt sie sie ganz gut: Es handelt sich um genau das, was man mit den Funktionen [[glTranslate]], [[glRotate]], [[glScale]], usw. bewirken kann. Verschiebungen haben wir bereits durch die Position des Objektes abgehakt, wir können uns hier also auf Dinge wie Scheerungen, Rotationen usw. beschränken. Wer Nachholbedarf in diesen Themen hat, der sollte sich jetzt hier darum kümmern, dieses Defizit etwas zu mildern. Da DelphiGl aber schon eine Weile existiert, finden sich fast alle nötigen Informationen in Tutorias oder Wiki-Artikeln: [[Matrix]],
[[Tutorial_Nachsitzen|Nachsitzen]], [[Tutorial_Matrix2|Matrix 2]], [[Quaternion]]. Auch die Wikipedia ist hier in der [http://de.wikipedia.org/wiki/Kategorie:Lineare_Algebra Kategorie Lineare Algebra] gut ausgestattet, um weitere Informationen einzuholen.
Wer hoch in den Code des Basis-Objektes schaut, dem wird auffallen, dass Transformationen durch das Interface ILinearTransformation definiert sind:

<source lang="cpp">
/// Defines a linear Trafo
public interface ILinearTransformation
{
/// Applys the Trafo to v
Vertex3 Apply(Vertex3 v);
/// Applys the inverse Trafo to v
Vertex3 ApplyInverse(Vertex3 v);

/// Conversion of the Trafo to Matrix3x3
Matrix3x3 ConvertTo3x3();
/// Conversion of the Inverse Trafo to Matrix3x3
Matrix3x3 ConvertInverseTo3x3();

/// Right Mulltiplication of factor with this to a new, returned ILinearTransformation.
/// Probably the trafos are converted to a LinearTransformationMatrix, but if both
/// trafos are of the same type, its a good idea to multiply them together.
ILinearTransformation MultiplyWithLinear(ILinearTransformation factor);
}
</source>

So kann man ohne weiteres Quaternionen und Matrizen wild nebeneinander verwenden. Mit der Methode MultiplyWithLinear kann man dann auch verschiedene Multiplikationen miteinander verknüpfen. So kann man Quaternionen einfach mit Quaternionen multiplizieren und gemischtes, wenn etwa Quaternionen mit Matrizen multipliziert werden, in Matrizen umwandeln:

<source lang="cpp">
#region ILinearTransformation Members

/// Rotates a Vertex3 through the Quaternion - this should be normalized!
public Vertex3 Apply(Vertex3 v) {...}
/// Rotates a Vertex3 against the Quaternion. A normalized Quaternion is assumed!
public Vertex3 ApplyInverse(Vertex3 v) {...}

/// Converts the Quaternion to a 3x3 Matrix
public Matrix3x3 ConvertTo3x3()
{
Matrix3x3 result = new Matrix3x3();
result.sp0 = Apply(new Vertex3(1.0, 0.0, 0.0));
result.sp1 = Apply(new Vertex3(0.0, 1.0, 0.0));
result.sp2 = Apply(new Vertex3(0.0, 0.0, 1.0));
return result;
}

/// Converts the Inverse Quaternion to a 3x3 Matrix
public Matrix3x3 ConvertInverseTo3x3()
{
Matrix3x3 result = new Matrix3x3();
result.sp0 = ApplyInverse(new Vertex3(1.0, 0.0, 0.0));
result.sp1 = ApplyInverse(new Vertex3(0.0, 1.0, 0.0));
result.sp2 = ApplyInverse(new Vertex3(0.0, 0.0, 1.0));
return result;
}

/// Multiply the Quaternion with another trafo. If its a Quaternion, this and factor
/// will be multiplied together, otherwise a LinearTransformationMatrix is generated.
public ILinearTransformation MultiplyWithLinear(ILinearTransformation factor)
{
if (factor == null) return this;
Quaternion fac = factor as Quaternion;
if (fac != null)
{
return Multiply(fac);
}
else
{
// factor is not wenn known to us, we need a new LinearTransformationMatrix
Matrix3x3 lin = ConvertTo3x3() * factor.ConvertTo3x3();
Matrix3x3 inv = factor.ConvertInverseTo3x3() * ConvertInverseTo3x3();
return new LinearTransformationMatrix(lin, inv, factor.Operator2Norm() * Operator2Norm());
}
}
#endregion
</source>
An diesem Beispiel aus meinem Quaternioncode kann man folgendes sehen: Die Funktionen ConvertTo3x3 und ConvertInverseTo3x3 berechnen jeweils die zum Quaternion gehörenden, äquivalenten Matrizen ( Man erinnere sich an den Satz, den ich bereits im Nachhilfe Tutorial zitiert habe: Die Spalten spi der Matrix sind die Bilder der Einheitsvektoren. Dann dürfte sofort klar sein, was hier passiert ). In MultiplyWithLinear wird dann einfach geprüft, ob die Transformation mit der rechts multipliziert wird, ein Quaternion ist. Dann wird einfach Quaternion-Multiplikation durchgeführt, ansonsten werden sowohl der Faktor als auch das betrachtete Quaternion in 3x3 Matrizen umgewandelt und in einer LinearTransformationMatrix abgelegt - welches natürlich ILinearTransformation implementiert und immer die Transformationsmatrix und ihr Inverses bereithält.

Damit ihr nicht ewig rumrechnen müsst (es handelt sich nämlich um eine schrecklich langwierige und ekelige Rechnerei: Ich habe etwa 2 Stunden gebraucht, bis das Ergebnis endlich fehlerfrei und brauchbar auf 2 DIN-A4 Blättern verteilt da stand), wenn ihr Quaternionen implementiert noch ein paar kleine Methoden des Quaternions. Den Rest werdet ihr dann wohl aus dem [[Quaternion|Quaternionen-Artikel]] selbst in kurzer Zeit zusammenstöpseln können.

<source lang="cpp"> // "Coordinates" of the Quaternion.
// coords[0] is the real component, coords[1] the i comp., ...
private double[] coords = new double[4];

/// Creates a rotation Quaternion
public Quaternion(double alpha, Vertex3 rotAxis)
{
alpha = (2.0*Math.PI/(360.0*2.0))* alpha;

coords[0] = 1.0;
if (rotAxis.Magnitude < double.Epsilon)
{
return;
}

rotAxis.Normalize();
double c, s;
c = Math.Cos(alpha); s = Math.Sin(alpha);
coords[0] = c; coords[1] = rotAxis[0] * s;
coords[2] = rotAxis[1] * s; coords[3] = rotAxis[2] * s;
}

/// Rotates a Vertex3 through the Quaternion - this should be normalized!
public Vertex3 Apply(Vertex3 v)
{
Vertex3 result = new Vertex3();
double v0 = v[0]; double v1 = v[1]; double v2 = v[2];
double a00 = coords[0] * coords[0];
double a01 = coords[0] * coords[1];
double a02 = coords[0] * coords[2];
double a03 = coords[0] * coords[3];
double a11 = coords[1] * coords[1];
double a12 = coords[1] * coords[2];
double a13 = coords[1] * coords[3];
double a22 = coords[2] * coords[2];
double a23 = coords[2] * coords[3];
double a33 = coords[3] * coords[3];
result[0] = v0 * (+a00 + a11 - a22 - a33)
+ 2 * (a12 * v1 + a13 * v2 + a02 * v2 - a03 * v1);
result[1] = v1 * (+a00 - a11 + a22 - a33)
+ 2 * (a12 * v0 + a23 * v2 + a03 * v0 - a01 * v2);
result[2] = v2 * (+a00 - a11 - a22 + a33)
+ 2 * (a13 * v0 + a23 * v1 - a02 * v0 + a01 * v1);
return result;
}
/// Rotates a Vertex3 against the Quaternion. A normalized Quaternion is assumed!
public Vertex3 ApplyInverse(Vertex3 v)
{
Vertex3 result = new Vertex3();
double v0 = v[0];
double v1 = v[1];
double v2 = v[2];
// Like Apply. We only konjugate the im. factors
double a00 = coords[0] * coords[0];
double a01 = -coords[0] * coords[1];
double a02 = -coords[0] * coords[2];
double a03 = -coords[0] * coords[3];
double a11 = +coords[1] * coords[1];
double a12 = +coords[1] * coords[2];
double a13 = +coords[1] * coords[3];
double a22 = +coords[2] * coords[2];
double a23 = +coords[2] * coords[3];
double a33 = +coords[3] * coords[3];
result[0] = v0 * (+a00 + a11 - a22 - a33)
+ 2 * (a12 * v1 + a13 * v2 + a02 * v2 - a03 * v1);
result[1] = v1 * (+a00 - a11 + a22 - a33)
+ 2 * (a12 * v0 + a23 * v2 + a03 * v0 - a01 * v2);
result[2] = v2 * (+a00 - a11 - a22 + a33)
+ 2 * (a13 * v0 + a23 * v1 - a02 * v0 + a01 * v1);
return result;
}
</source>
Wer ein Quaternion mithilfe des angegebenen Konstruktors erstellt, erhält ein Rotationsquaternion der Norm 1. Genau das, was für die Funktionen Apply und ApplyInverse notwendig ist, damit sie das tun, was sie sollen. Damit soll ersteinmal der Faulheit beim Rechnen und dem Copy&Paste genüge getan sein. Und wehe ich entdecke irgendwann Raytracer, die Objekte nur rotieren können statt beliebige [[Matrix|Matrizen]] zu vertragen ;-) Am Ende bleibt es natürlich euch überlassen. Wenn ihr wollt, könnt ihr all das auch allein durch Matrizen implementieren und euch den Umweg über das Quaternion ersparen - allerdings sieht man einem Quaternion schneller an was es bewirkt, als einer Matrix.

Nachdem wir einen kleinen Ausflug in Richtung Quaternionen und Transformationen hinter uns gebracht haben, könnte man hoffen, dass wir jetzt endlich mit dem abstrakten Kram aufhören und wir bald mal wieder ein paar neue Bilder zu Gesicht bekommen. Soweit ist es leider noch nicht. Ich möchte zwischendrin den Schlachtplan für die nächsten Minuten bekannt geben: Wir werden jetzt die Punkte in den Trans-Space-Funktionen der Basisklasse füllen, um uns dann dem Licht durch Phong-Lighting über den Umweg der Normalen zu widmen. Beginnen wir also mit der Funktion TransSpaceParentToObject, welche Strahlen des elterlichen Raumes in den lokalen Raum transformieren soll. Wenn man nun an die Kameraanalogie denkt, wie sie etwa im [[Tutorial_Kamera1|Kamera Tutorial]] beschrieben ist, dann wissen wir, dass wir die auf das Objekt angewendete Transformation einfach nur umkehren müssen. Denkt man dann noch daran, dass wir erreichen wollen, dass das Objekt im lokalen Raum am Ursprung befinden soll, ist die Implementation schnell naheliegend: Den Ursprung des Strahles müssen wir erst um die Position verschieben und dann invers transformieren. Bei der Richtung genügt es, diese invers zu transformieren.

<source lang="cpp">
public virtual Ray TransSpaceParentToObject(Ray r)
{
Ray ray = r;
ray.Origin -= pos;
if (ptransformation != null)
{
ray.Origin = ptransformation.ApplyInverse(ray.Origin);
ray.Direction = ptransformation.ApplyInverse(ray.Direction);
}
return ray;
}
</source>
Bei dieser Überlegung fallen auch gleich die Funktionen TransSpacePointParentToObject, welche einen Punkt in die lokalen Koordinaten überträgt und die Entsprechende Funktion TransSpaceParentToObject für Richtungen ab. Das ganze können wir natürlich auch in die andere Richtung machen: Bislang ist mir aber noch kein Grund eingefallen, dies zu tun. Wichtig dagegen ist es, Richtungen in Weltkoordinaten umzurechnen, da wir dies für die Normalen später benötigen werden. Dies erreichen wir leicht, wenn wir ausnutzen, dass Objekte immer ihre Eltern kennen:

<source lang="cpp"> public virtual Vertex3 TransSpaceObjectToWorld(Vertex3 v)
{
if (ptransformation != null)
{
v = ptransformation.Apply(v);
}
if (fParent != null)
{
v = fParent.TransSpaceObjectToWorld(v);
}
return v;
}
</source>
Die entsprechende Funktion für Punkte solltet ihr der Übung halber selbst schreiben. Mit den genannten Zweien kommen wir auf jeden Fall erst einmal aus - ich bin mir gar nicht sicher, ob in meinem eigenen Raytracer je die Anderen zum Einsatz gekommen sind. Naja, es schadet jedenfalls nicht, wenn sie da sind.

[[Bild:Tutorial_RaytracingII_spherenormals.jpg|right|framed|Visualisierung der Normalen]]
Um nun mit dem Licht weiter machen zu können, müssen wir die Intersect-Funktionen für Kugeln und Ebenen um Normalenerzeugung erweitern. Wir dürfen nicht vergessen, diese dann in den World-Space zu transformieren:

<source lang="cpp"> /// Calculates the World-Space normal for a surface point
protected Vertex3 CalcNormal(Vertex3 v)
{
Vertex3 normal = TransSpaceObjectToWorld(v);
normal.Normalize();
return normal;
}
...
public override int Intersect(RenderSettings rs, Ray ray,
double raymindist, double raymaxdist, bool calcNormals,
bool calcTextureCoordinates, ref IntersectionInfo info)
{
Ray osray = TransSpaceParentToObject(ray);

double a, b, c;
a = osray.d.DotDot; b = 2 * (osray.o * osray.d);
c = osray.o.DotDot - sphereRadius * sphereRadius;

double t1, t2;
int roots = GeoMath.CalcQuadricRoots(a, b, c, out t1, out t2);

// roots are sorted so check only for tr2
if (roots > 0 && t2 >= raymindist && t1 <= raymaxdist)
{
info = new IntersectionInfo();
Vertex3 v; info.material = ObjectMaterial;

info.rayPosition = t1;
if (t1 >= raymindist)
{
v = osray.Evaluate(t1);
if (calcNormals) info.normal = CalcNormal(v);
if (calcTextureCoordinates)
info.texture = GeoMath.SphereCoordinates(v);
return 1;
}

v = osray.Evaluate(t2);
if (calcNormals) info.normal = CalcNormal(v);
if (calcTextureCoordinates)
info.texture = GeoMath.SphereCoordinates(v);
info.rayPosition = t2;
return 1;
}
else
return -1;
}
</source>

== Phong Licht ==
[[Bild:Tutorial_RaytracingII_phong.jpg|center]]

Wir sind soweit. Die ersten hübscheren Bilder aus unserem Raytracer sind greifbar nahe. Wir müssen uns im wesentlichen nur noch mit Phong Licht beschäftigen, um aus unserem Raytracer mehr herauszuquetschen. Das Phong-Beleuchtungsmodell ist ein sehr einfaches Modell, um Licht zu simulieren. Es ist physikalisch ziemlich falsch: Durch Hinzufügen von Objekten in einen physikalischen Raum, die sich lichttechnisch nach dem Phong Modell verhalten, wird i.A. die vorhandene Lichtenergie erhöht. Das ist sehr tragisch, wenn man globale Beleuchtungsmethoden verwendet, aber fürs erste ist es ein sehr gut aussehendes und leicht zu berechnendes Modell. Wir wollen uns also von dieser Anomalität nicht beunruhigen lassen und uns nur daran erinnern, wenn wir einmal globale Beleuchtungsmethoden einführen wollen. Jedem sollte das Phong Modell wohl vertraut sein, da es das Standard-Modell in OpenGl ist. Wer hier noch Nachholbedarf hat, schaue doch einmal im [[Beleuchtung|Beleuchtungs-Artikel]] oder [http://www.delphi3d.net/articles/viewarticle.php?article=phong.htm in Tom Nuydens': Phong For Dummies].

Jedenfalls, wenn wir jedem Objekt ein Material mit den Koeffizienten aus dem Phong-Modell zugeordnet haben, dann können wir mithilfe einer IntersectionInfo für Strahl/Objekt-Schnittpunkte und aller Lichtquellen leicht die zugehörige Farbe bestimmen. An der Stelle, wo wir also im Tiefentracer den Grauwert bestimmten, bestimmen wir
jetzt den zugehörigen Farbwert über unser Material:

<source lang="cpp">public RaytraceImage ( int width , int height )
{
for ( int x = 0; x < width; x++) {
for ( int y = 0 ; y < height; y++) {
Ray shoot = ShootRay (x , y);
double maxdist = double.Infinity;

IntersectionInfo cinfo = new IntersectionInfo();;
IntersectionInfo iinfo = new IntersectionInfo();

foreach (ObjectBase obj in SichtbareObjekte) {
if (obj.Intersect(rs, shoot, 0, maxdist, true, true, ref cinfo) > 0
&& cinfo.rayPosition < maxdist) iinfo = cinfo;
}

if (maxdist < double.Infinity && iinfo.material != null) {
SetColor(x, y, iinfo.Material.GetColor(iinfo));
}
else
SetColor(x, y, BackgroundColor);
}
}
}
</source>

== Abschluss ==
Da habt ihr euch ja durch ein dickes Ding gequält ( besonders wenn ihr im Bereich Transformationen oder Phong noch Nachholbedarf hattet, hats sicher eine Weile gedauert ). Gratulation. Langsam wird das Raytracing ja interessant und die Szenen sind nicht mehr ganz so langweilig. Es bleibt aber immer noch genügend Stoff für ein weiteres Grundlagen Tutorial: In Planung sind hier ein paar Worte bezüglich Reflexionen, Schatten und ein paar weiteren Objekten wie Dreiecken (das impliziert eine Lehrstunde in Sachen Phong Shading), Boxen und Zylinder. Dazu sollten wir außerdem unseren Raytracer umbauen: Er wird in eine eigene Tracer-Klasse ausgelagert werden, um so schnell die Wahl zwischen verschiedenen Raytracern zu haben. Stay tuned.

'''Delphic'''

[[Kategorie:Tutorial|Raytracing - Grundlagen II]]

Tutorial Wassereffekt

2014-03-09T10:58:29Z

Glawesome: /* In the end... */ Kategorie hinzugefügt

= Einleitung =
Erstmal willkommen zu meinem zweiten Tutorial. Ich möchte Euch hier einen Einblick in die „hohe Kunst“ der Wassereffekte geben. Hierbei wird erst einmal nur ein relativ stehendes Gewässer, also keines, welches in einer Rinne fließt beschrieben. Auch werde ich hier nicht auf die Technik für Wasser an Abhängen (abwärts fließende Flüsse) oder Wasserfälle eingehen. Hier geht es schlicht und einfach um eine Wasserebene, wie man sie zum Beispiel für ein Meer verwenden könnte.

Voraussetzung für dieses Tutorial ist eigentlich nur ein Delphi/FP-Kompiler, einige grundlegende Kenntnisse in OpenGL und in GLSL. Falls letztere fehlen, kann ich nur die beiden Tutorials zum Thema GLSL hier im Wiki empfehlen: [[Tutorial_glsl|Tutorial GLSL]] und [[Tutorial_glsl2|Tutorial GLSL 2]].

Noch etwas, dass man wissen sollte ist, dass die Kamera in die GL_PROJECTION_MATRIX geschrieben wird. Dies wird später für die Shader wichtig. Das ist kaum mehr Arbeit mit großer Wirkung, da sich dieses Tutorial an fortgeschrittene Benutzer richtet, werde ich hier allerdings nicht näher drauf eingehen. Durch diese Trennung haben wir dann den Vorteil, dass die eigene Rotation der Modelle von den Operationen der Kamera getrennt ist. Das wird wie erwähnt bei den Shadern wichtig.

In dem Sinne: glBegin(GL_WATER_TUTORIAL) ;-)

= Die Wasserebene =
Das Erste, das wir brauchen ist eine Ebene - am besten Quads - von mir aus auch zwei Triangles. Wichtig ist, dass es eine [[Ebene]] ist. Es darf keine Höhenunterschiede geben. Die Z-Achse sollte hierbei die Höhe darstellen, X und Y dienen als... als X und Y eben ;) Natürlich fehlt noch so ziemlich alles. Diese Ebene allein macht nicht einen Wassereffekt aus. Jetzt brauchen wir erst einmal ein paar Texturen. Diese sollten der "Power of Two"-Regel gemäß und quadratisch sein. Dabei muss man beachten, dass sie keinesfalls größer als der maximal beschreibbare Viewport sein sollten, weil die Texturen komplett gefüllt werden müssen. Der Grund dafür ist, dass man nicht über den Rand des Framebuffers (des Fensters) zeichnen kann, zuminest nicht ohne Erweiterungen, also muss die Textur kleiner oder genauso groß wie der Framebuffer sein. Diese Texturen sollten bereits zu Anfang des Programms erstellt und initialisiert werden. Genau genommen brauchen wir zwei Stück. Jeweils eine für die Reflexions- und Refraktionsmap. Wenn wir ohne Shader arbeiten, sollten sie nur als RGB initialisiert werden. Wenn wir später den Shader zuschalten, brauchen wir auch den Alphakanal. Die Größe sollte sich am originalen Viewport ausrichten. Die Texturen lassen sich übrigens am Besten mit glCopyTexImage2D initialisieren, da man dort keinen Puffer mit Pixeldaten braucht, den man übergeben muss.

= Texturen füllen =
Jetzt geht es darum, wie wir die Szene in die Texturen und dann auf die Wasserebene bekommen. Hier kann ich einen Trick empfehlen, den ich aus einer Demo von Delphi3d.net habe- aber dazu gleich noch mehr.

Wichtig ist vor allem, das wir uns erst einmal Gedanken machen, was die Texturen eigentlich beinhalten sollen. Refract sollte - wie der Name bereits sagt - die Refraktionsinformationen, also alles, was unter dem Wasser ist, darstellen, Reflect, daher das, was über dem Wasser ist. Damit keine Darstellungsfehler entstehen, wenn die Kamera über dem Wasser ist, müssen wir beim Erstellen der Texturen die Parameter {{INLINE_CODE|GL_TEXTURE_WRAP_S}} und {{INLINE_CODE|GL_TEXTURE_WRAP_T}} auf {{INLINE_CODE|GL_CLAMP_TO_EDGE}} setzen.
Wer schon etwas häufiger mit OpenGL gearbeitet hat, der kann sich vielleicht schon denken, wie man die Texturen am Besten füllen kann: natürlich mit ClipPlanes. Diese praktischen Dinger sorgen dafür, dass alles, was über bzw. unter ihnen liegt, abgeschnitten und nicht gezeichnet wird. Am besten für die Performance wäre es natürlich, wenn wir in der Anwendung noch einmal prüfen, ob das Objekt nicht vielleicht ganz unter/über Wasser ist und man es deshalb in diesem Renderpass weglassen könnte, aber das würde den Rahmen des Tutorials sprengen. Außerdem müssen wir dann noch entsprechend der aktuell zu füllenden Textur die Z-Achse invertieren je nachdem , ob wir den Teil über oder den Teil unter der Wasseroberfläche rendern wollen.

<source lang="pascal">procedure DoRenderPass(InvertZ: Boolean);
const
// Deklaration der ClipPlane
CP: array [0..3] of Double = (0.0, 0.0, 1.0, 0.0);
begin
glEnable(GL_CLIP_PLANE0);
glDisable(GL_CULL_FACE);

glLoadIdentity;
glClipPlane(GL_CLIP_PLANE0, @CP);

if InvertZ then
glScalef(1, 1, -1);
RenderGameScene;

glDisable(GL_CLIP_PLANE0);
glEnable(GL_CULL_FACE);
end;</source>
Das sollte soweit klar sein. Jetzt zu dem eigentlichen Inhalt von RenderWaterMap.

Dort muss zunächst einmal der komplette Viewport geleert werden. Danach sollte der Viewport auf die Größe von WaterTexSize verkleinert werden, damit das Gerenderte letztendlich auch auf die Texturen passt. Jetzt kommen wir langsam zu dem Trick, den ich weiter oben erwähnte: Erst einmal muss die Texturmatrix auf die Identitätsmatrix zurückgesetzt werden. Weiter geht es mit dem ersten Renderpass für die Reflexion. Das Ergebnis sollte in die Reflect-Textur gespeichert werden. Danach die Szene noch einmal rendern (nicht vergessen, vorher die Textur wieder zu unbinden), diesmal jedoch ohne Invertierung der Z-Achse. Das kommt dann logischerweise in die Refract-Textur, weil die ClipPlane hier alles unter der Wasseroberfläche da lässt und den Rest abschneidet. Zu guter Vorletzt den Viewport wieder auf den Zustand zurücksetzen, auf dem er vor dem Rendern war und nochmal den Framebuffer leeren.

Jetzt wird es interessant: In der Texturmatrix müssen folgende Operationen durchgeführt werden: Verschieben um (0.5, 0.5, 0.0) und skalieren um (0.5, 0.5, 0.0). Dann eine Perspektive mit dem Seitenverhältnis, welches wir auch in unserer „echten“ Szene haben erzeugen und danach die Kameraoperationen durchführen.

Und jetzt der Code dazu:
<source lang="pascal">
glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);

glViewport(0, 0, WaterTexSize, WaterTexSize);

glMatrixMode(GL_TEXTURE);
glLoadIdentity;
glMatrixMode(GL_MODELVIEW);

DoRenderPass(True);

glBindTexture(GL_TEXTURE_2D, Reflect);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, WaterTexSize, WaterTexSize);
glBindTexture(GL_TEXTURE_2D, 0);

if UseWaterShader then
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);

DoRenderPass(False);

glBindTexture(GL_TEXTURE_2D, Refract);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, WaterTexSize, WaterTexSize);
glBindTexture(GL_TEXTURE_2D, 0);

// Hier bitte die eigenen Werte einsetzen
glViewport(0, 0, Settings.ScreenWidth, Settings.ScreenHeight);

glClear(GL_DEPTH_BUFFER_BIT or GL_COLOR_BUFFER_BIT);

glMatrixMode(GL_TEXTURE);
glLoadIdentity;
glTranslatef(0.5, 0.5, 0);
glScalef(0.5, 0.5, 0);

gluPerspective(PERSPECTIVE_FOV, Settings.ScreenWidth/Settings.ScreenHeight, 0.01, 100000);
DoCamTranslate;
DoCamRotate;
glMatrixMode(GL_MODELVIEW);

glBindTexture(GL_TEXTURE_2D, 0);
</source>

= Wasser marsch =
Jetzt zu der Wasserebene. Sicher kann man sich denken, dass aus dem Weiß noch mehr wird. Jetzt kommen wir zu der Sache mit der Texturmatrix. Die ist dank unserer Routine jetzt so aufgebaut, dass die übergebenen Texturkoordinaten wie in der normalen Projektionsmatrix verarbeitet werden. Das ermöglicht es als Texturkoordinaten genau die Werte zu übergeben, die auch glVertex3f bekommt. Das ist eine große Erleichterung, was vor allem nerviges hin- und hergerechne erspart. Da wir uns erst einmal mit dem non-shader-way befassen wollen, sieht unser Code für die Wasserebene jetzt so aus:

<source lang="pascal">glEnable(GL_TEXTURE_2D);

glColor4f(1.0, 1.0, 1.0, 1.0);
glBindTexture(GL_TEXTURE_2D, Reflect);

glDepthMask(GL_FALSE);
glBegin(GL_QUADS);
glTexCoord3f(-100.0, -100.0, 0.0);
glVertex3f(-100.0, -100.0, 0.0);
glTexCoord3f(-100.0, 100.0, 0.0);
glVertex3f(-100.0, 100.0, 0.0);
glTexCoord3f(100.0, 100.0, 0.0);
glVertex3f(100.0, 100.0, 0.0);
glTexCoord3f(100.0, -100.0, 0.0);
glVertex3f(100.0, -100.0, 0.0);
glEnd;

glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

glDepthMask(GL_TRUE);
glBindTexture(GL_TEXTURE_2D, Refract);
glColor4f(1.0, 1.0, 1.0, RefractAlpha);
glBegin(GL_QUADS);
glTexCoord3f(-100.0, -100.0, 0.0);
glVertex3f(-100.0, -100.0, 0.0);
glTexCoord3f(-100.0, 100.0, 0.0);
glVertex3f(-100.0, 100.0, 0.0);
glTexCoord3f(100.0, 100.0, 0.0);
glVertex3f(100.0, 100.0, 0.0);
glTexCoord3f(100.0, -100.0, 0.0);
glVertex3f(100.0, -100.0, 0.0);
glEnd;

glBindTexture(GL_TEXTURE_2D, 0);

glDisable(GL_TEXTURE_2D);
glDisable(GL_BLEND);</source>
Die Texturkoordinaten sollten ja jetzt klar sein. Zuerst wird die Reflexionstextur gerendert, danach folgt die Refraktionstextur. Dabei wird erstere mit vollem Alpha gerendert und die andere darüber geblendet. Bei den Shadern werden beide Texturen gebunden und an den Shadern übergeben, dazu jedoch gleich mehr. [[Bild:Ld_watertutorial_step1.jpg|thumb|right|Die einfache Wasserebene ohne Wellen (von littleDave)]] Rechts könnt ihr euch von eurem Ergebnis überzeugen.

= Auf zu den Shadern =
Für die Shader müssen wir eigentlich kaum Änderungen vornehmen, zumindest solange wir beim simplen Einbauen von Wellen bleiben. Gleich werde ich noch auf eine Technik eingehen, die nervige Kanten an Grenzen zu Objekten vermeidet. Die Änderungen betreffen zunächst allein den Code, der die Ebenen selber rendert. Außerdem brauchen wir noch eine weitere Textur, die die Bumpmap der Wasseroberfläche darstellt und für die Wellen verwendet wird. Jetzt werden im Rendercode für die Wasserebene noch einige Änderungen durchgeführt. Zunächst brauchen wir nur noch ein Quad, da der Shader das Überblenden übernimmt. Vor dem Rendern des Quads sollte der Shader gebunden werden, sowie die drei Texturen in drei Textureinheiten geschoben werden, in der Reihenfolge Reflect-Refract-WaterBumpmap. Dann muss noch ein Haufen Parameter an den Shader übergeben werden. Erstmal der Standardkram, die Zuweisung der Texturen. Der Uniform-Integer refractTex wird 1, reflectTex wird 0 und bumpMap wird 2. Dann gibt es noch einige Variablen, die die Darstellung und die Stärke des Wassereffektes beeinflussen: reflectRatio und refractRatio sind ein Faktor, mit dem die Bumpmap multipliziert wird und der die Stärke des Effektes beeinflusst. Ich empfehle für beides einen Wert um 1/20.0. Dann gibt es noch mappingRatio und extendedBlending, die erkläre ich später beim Shader selbst.

Da wir jetzt zwei verschiedene Texturarten verwenden, einmal die projizierten Reflect- und Refracttexturen und die BumpMaptexturen, sollten wir auch noch eine zweite Texturkoordinate übergeben, und zwar für die Bumpmaps. Welchen Wert Ihr hier einsetzt, ist Eure Sache.

Jetzt zu dem Shader, dem wir die Werte übergeben wollen. Erst einmal ein kurzes Brainstorming. Was brauchen wir? Zunächst müssen die Texturen entsprechend der Matrizen transformiert werden. Danach müssen sie wiederum entsprechend der Bumpmaps verschoben werden, so dass ein Welleneffekt entsteht. Dies alles passiert im Fragmentshader. Der Vertexshader dagegen sieht recht harmlos aus:

<source lang="glsl">varying mat4 texMat;

void main(void)
{
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
gl_TexCoord[0] = gl_MultiTexCoord0;
texMat = gl_TextureMatrix[0];
gl_TexCoord[1] = gl_MultiTexCoord1;
gl_FrontColor = gl_Color;
}</source>
Was im Vertexshader passiert, sollte wohl ziemlich klar sein. In Zeile 5 wird erst einmal der Vertex anhand der normalen Matrizen projiziert, so dass es die gleiche Wirkung hat, als wenn man es durch die normale Renderpipe jagen würde. Zeilen Sechs und Acht sind dafür zuständig, dass die Texturkoordinaten auch im Fragmentshader verwendet werden können. Zeile Sieben speichert die Texturmatrix in einer Varying, so dass wir sie ebenfalls im Fragmentshader verwenden können. Die neunte Zeile speichert noch die Farbe - eher unwichtig und man könnte es auch weglassen, aber ich fand es schön ;). Genug der Scherze, weiter mit dem Fragmentshader:

<source lang="glsl">uniform sampler2D refractTex;
uniform sampler2D reflectTex;
uniform sampler2D bumpMap;

uniform float refractRatio;
uniform float reflectRatio;

uniform float mappingRatio;

uniform int extendedBlending;

varying mat4 texMat;

void main(void)
{
vec4 refractcoord;
vec4 reflectcoord;
vec4 offsetColor = (texture2D(bumpMap, vec2(gl_TexCoord[1])) +
texture2D(bumpMap, vec2(gl_TexCoord[1]) * 4.0)) / 2.0;
vec4 origOffset = offsetColor;
vec4 color;
vec4 reflectColor = vec4(1.0, 1.0, 1.0, 1.0);
vec4 refractColor = vec4(1.0, 1.0, 1.0, 1.0);
vec4 blendedColor;

offsetColor -= 0.5;
offsetColor *= 2.0;

refractcoord = gl_TexCoord[0];
refractcoord.x += offsetColor[0] * refractRatio;
refractcoord.z += offsetColor[1] * refractRatio;
refractcoord = texMat * refractcoord;
refractColor = texture2DProj(refractTex, refractcoord);

reflectcoord = gl_TexCoord[0];
reflectcoord.x += offsetColor[0] * reflectRatio;
reflectcoord.z += offsetColor[1] * reflectRatio;
reflectcoord = texMat * reflectcoord;
reflectColor = texture2DProj(reflectTex, reflectcoord);

reflectColor[3] = 1.0;
refractColor[3] = 1.0;

if (extendedBlending == 0)
{
float mappingRefract, mappingReflect;
mappingRefract = mappingRatio * 255.0;
mappingReflect = 255.0 - mappingRefract;
mappingRefract /= 255.0;
mappingReflect /= 255.0;
blendedColor = refractColor * mappingRefract + reflectColor * mappingReflect;
blendedColor.a = 1.0;
}
else
{
float Alpha, reflectAlpha, refractAlpha;
Alpha = (refractColor.r + refractColor.g + refractColor.b) / 3.0;
if (Alpha > 1.0)
Alpha = 1.0;
if (Alpha < 0.0)
Alpha = 0.0;

refractAlpha = Alpha * 255.0;
reflectAlpha = 255.0 - refractAlpha;
refractAlpha /= 255.0;
reflectAlpha /= 255.0;
blendedColor = reflectColor * reflectAlpha + refractColor * refractAlpha;
}

gl_FragColor = blendedColor;
}</source>
Das ist recht viel Quelltext auf einmal. Aber wir schauen ihn uns nun stückchenweise an. Die ersten Zeilen deklarieren die verwendeten Uniforms. Dann wird noch das texMat-Varying aus dem Vertexshader übernommen. Wie wir bereits vorhin gelernt haben, ist die Texturmatrix unerlässlich, um die Textur einfacher auf die Ebene zu projizieren. Im Hauptcode haben wir dann einen ganzen Haufen Variablendeklarationen. Hervor sticht offsetColor, für das zwei Texturzugriffe verwendet werden, um die Farbe aus der Bumpmap zu lesen. Zwei Zugriffe deshalb, um das Wasser ein wenig detaillierter zu machen. Danach wird offsetColor skaliert: Eine normale Bitmap hat nun einmal nicht die Möglichkeit, negative Werte zu speichern, aber es würde ohne diese sehr eintönig aussehen. Danach wird das Offset für Reflexion und Refraktion berechnet. Das läuft bei beiden ähnlich ab: Die Texturkoordinate wird mit der Matrix multipliziert und erst einmal in einer Variable gespeichert, dann wird der Wert aus der Map gelesen und das Alpha auf 1.0 gesetzt.

[[Bild:Ld_watertutorial_step2.jpg|thumb|right|Der zweite Schritt: Die Shader-Wellen sind deutlich sichtbar (von littleDave)]]Weiter geht es mit dem Schalter zwischen erweitertem Blending und normalem Blending. Das erweiterte Blending versucht eine Wasseroberfläche von der Lichtdurchlässigkeit möglichst realistisch darzustellen, indem die Sichtbarkeit der Objekte unterhalb der Oberfläche, also dem Teil in der Refraktionsmap, der Helligkeit der Reflexion angepasst: Wenn man mit einer Lampe auf eine Wasseroberfläche leuchtet, kann man schlechter durch die von der Lampe getroffene Stelle blicken, weil die Reflexion der Lampe das, was darunter liegt, überstrahlt. Zu guter Letzt wird im Shader noch die berechnete Farbe an OpenGL zurückgegeben, sodass sie dann in den Framebuffer geschrieben werden kann. mappingRatio legt übrigens das Verhältnis zwischen Reflexion und Refraktion fest, falls erweitertes Blending deaktiviert ist (also extendedBlending = 0). Ein Wert von 1.0 würde bedeuten, dass nur die Refraktionsmap gerendert wird, ein Blending von 0.0 bedeutet, dass nur die Reflexionsmap durchkommt. Diese Multiplikationen da oben mache ich übrigens, um ein Problem mit der Genauigkeit des Floats im Shader zu umgehen. Rechts nochmal ein Bild zum aktuellen Status. Da erkennt man schon deutlich die Wellen und, wenn man genauer hinschaut, erkennt man auch eine unschöne Linie beim Übergang von der Wasserebene zum Objekt.

= Feintuning =
Wenn man jetzt einfach einen Würfel in die Wasserfläche setzt, der auf der Vorder- und der Rückseite verschiedene Farben hat, dann wird sichtbar, dass durch die Wellen unschöne Kanten entstehen, weil die Refraktions-/Reflexionsmap keine Objektgrenzen kennt. Doch dafür gibt es eine simple aber dennoch wirkungsvolle Methode, die ich jetzt beschreibe. Hierzu müssen wir den Code für das Rendern der Texturen leicht anpassen:

<source lang="pascal"> glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
glViewport(0, 0, WaterTexSize, WaterTexSize);

glMatrixMode(GL_TEXTURE);
glLoadIdentity;
glMatrixMode(GL_MODELVIEW);

DoRenderPass(True);

if UseDepthShader then
begin
glColorMask(False, False, False, True);
glClear(GL_DEPTH_BUFFER_BIT);

glUseProgramObjectARB(DepthShader);
glUniform1fARB(glGetUniformLocationARB(DepthShader, 'waterplaneZ'), 0.0);
DoRenderPass(True);
glUseProgramObjectARB(0);
glColorMask(True, True, True, True);
end;

glBindTexture(GL_TEXTURE_2D, Reflect);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, WaterTexSize, WaterTexSize);
glBindTexture(GL_TEXTURE_2D, 0);

if UseWaterShader then
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);

if UseDepthShader then
begin
glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
glColorMask(True, True, True, True);

glUseProgramObjectARB(DepthShader);
DoRenderPass(False);
glUseProgramObjectARB(0);

glColorMask(True, True, True, False);
glClear(GL_DEPTH_BUFFER_BIT);
end;

DoRenderPass(False);

glColorMask(True, True, True, True);

glBindTexture(GL_TEXTURE_2D, Refract);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, WaterTexSize, WaterTexSize);
glBindTexture(GL_TEXTURE_2D, 0);

// Hier bitte die eigenen Werte einsetzen
glViewport(0, 0, Settings.ScreenWidth, Settings.ScreenHeight);

glClear(GL_DEPTH_BUFFER_BIT or GL_COLOR_BUFFER_BIT);

glMatrixMode(GL_TEXTURE);
glLoadIdentity;
glTranslatef(0.5, 0.5, 0);
glScalef(0.5, 0.5, 0);

gluPerspective(PERSPECTIVE_FOV, Settings.ScreenWidth/Settings.ScreenHeight, 0.01, 100000);
DoCamTranslate;
DoCamRotate;
glMatrixMode(GL_MODELVIEW);

glBindTexture(GL_TEXTURE_2D, 0);</source>
Wieder ein riesiger Codeblock, aber das meiste kennen wir ja bereits. Das einzige, was dazugekommen ist, sind die if UseDepthShader-Blöcke. UseDepthShader ist mal wieder eine Variable, die Ihr ruhig deklarieren solltet, um die Verwendung des DepthShaders einzuschränken. DepthShader sollte wieder mal eine Variable für den Namen des Shaderprogramms sein. Ich missbrauche hier den Alpha-Kanal der Texturen für Tiefeninformationen. Dies ist insofern sinnvoll, dass man nicht extra eine Textur braucht und daher auch die Shader relativ einfach zu erweitern sind. Aber jetzt erst einmal zum Tiefenshader. Hier haben wir wieder einen recht unspektakulären Vertexshader:

<source lang="glsl">varying vec4 vpos;
varying vec4 ppos;

void main(void)
{
vpos = gl_ModelViewMatrix * gl_Vertex;
ppos = gl_ModelViewProjectionMatrix * gl_Vertex;
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
gl_FrontColor = gl_Color;
gl_ClipVertex = vpos;
}</source>
Obwohl es eher wie ein normaler Shader aussieht, ist es doch interessanter als man glaubt. Jetzt kommt uns der Vorteil zugute, dass wir die Kamera in der Projektionsmatrix haben. Wir können einfach die Kameraoptionen außen vor lassen und nur die Operationen, die in der Modelview-Matrix stehen auf den Vertex anwenden. Das erleichtert das Errechnen des Z-Wertes des Vertex ungemein. Jetzt zum Fragmentshader:

<source lang="glsl">uniform float waterplaneZ;

varying vec4 vpos;
varying vec4 ppos;

void main(void)
{
float y, z;
y = waterplaneZ - vpos.z;
z = ppos.z;

gl_FragColor = vec4(z, z, z, y);
}</source>
Hier werden die im Vertexshader berechneten Werte verwendet, um die Höhe des Vertices in den Alphakanal zu schreiben. Angemerkt werden sollte, dass die RGB-Informationen dank des glColorMask in RenderWaterMap verworfen werden. WaterplaneZ ist übrigens der Z-Wert der Wasserebene, in unserem Beispiel also 0.0, wie aus dem obigen Code hervorgeht.

Jetzt müssen wir nur noch den Wassershader so verändern, dass er die jetzt im Alphakanal vorhandenen Informationen auch sinnvoll nutzt. Der Vertexshader bleibt dabei, wie er ist, aber der Fragmentshader sieht jetzt so aus:

<source lang="glsl">uniform sampler2D refractTex;
uniform sampler2D reflectTex;
uniform sampler2D bumpMap;

uniform float refractRatio;

uniform float reflectRatio;

uniform float mappingRatio;

uniform int extendedBlending;

varying mat4 texMat;

void main(void)
{
vec4 refractcoord;
vec4 reflectcoord;
vec4 offsetColor = (texture2D(bumpMap, vec2(gl_TexCoord[1])) +
texture2D(bumpMap, vec2(gl_TexCoord[1]) * 4.0)) / 2.0;
vec4 origOffset = offsetColor;
vec4 color;
vec4 reflectColor = vec4(1.0, 1.0, 1.0, 1.0);
vec4 refractColor = vec4(1.0, 1.0, 1.0, 1.0);
vec4 blendedColor;

offsetColor -= 0.5;
offsetColor *= 2.0;

refractcoord = texMat * gl_TexCoord[0];
refractColor = texture2DProj(refractTex, refractcoord);
refractcoord = gl_TexCoord[0];
refractcoord.x += offsetColor[0] * refractColor[3] * refractRatio;
refractcoord.z += offsetColor[1] * refractColor[3] * refractRatio;
refractcoord = texMat * refractcoord;

reflectcoord = texMat * gl_TexCoord[0];
reflectColor = texture2DProj(reflectTex, reflectcoord);
reflectcoord = gl_TexCoord[0];
reflectcoord.x -= offsetColor[0] * reflectColor[3] * reflectRatio;
reflectcoord.z -= offsetColor[1] * reflectColor[3] * reflectRatio;
reflectcoord = texMat * reflectcoord;

reflectColor = texture2DProj(reflectTex, reflectcoord);
refractColor = texture2DProj(refractTex, refractcoord);

reflectColor[3] = 1.0;
refractColor[3] = 1.0;

if (extendedBlending == 0)
{
float mappingRefract, mappingReflect;
mappingRefract = mappingRatio * 255.0;
mappingReflect = 255.0 - mappingRefract;
mappingRefract /= 255.0;
mappingReflect /= 255.0;
blendedColor = refractColor * mappingRefract + reflectColor * mappingReflect;
blendedColor.a = 1.0;
}
else
{
float Alpha, reflectAlpha, refractAlpha;
Alpha = (refractColor.r + refractColor.g + refractColor.b) / 3.0;
if (Alpha > 1.0)
Alpha = 1.0;
if (Alpha < 0.0)
Alpha = 0.0;

refractAlpha = Alpha * 255.0;
reflectAlpha = 255.0 - refractAlpha;
refractAlpha /= 255.0;
reflectAlpha /= 255.0;
blendedColor = reflectColor * reflectAlpha + refractColor * refractAlpha;
}

gl_FragColor = blendedColor;
}</source>

[[Bild:Ld_watertutorial_step3.jpg|thumb|right|Der finale Wassereffekt mit Wellen und "Kantenerkennung" (von littleDave)]]Der neue Code multipliziert das Offset nochmal mit dem Alpha-Wert, in unserem Falle also die Distanz zwischen der Wasserebene und dem Pixel. Dadurch werden die Wellen je näher der Pixel an der Wasseroberfläche ist, immer niedriger. So werden an der direkten Kante zu dem Objekt, also da, wo der Alpha-Wert 0.0 ist, gar keine Wellen mehr erzeugt. Damit ist die nervige Kante weg. So sieht das ganze zum Schluss aus.

= In the end... =
Das war es eigentlich. Wenn alles so läuft, wie es soll, dann habt ihr jetzt eine schöne Ebene mit Wassereffekt. Die Shader sowie der andere Code dürfen natürlich beliebig weiterverwendet werden. Verbesserungsvorschläge, Kritik, Feedback jeglicher Art und Morddrohungen wie immer einfach an mich im Forum wenden.

glEnd;

Gruss [[Benutzer:Lord Horazont|Lord Horazont]]

{{TUTORIAL_NAVIGATION|[[Tutorial Alphamasking]]|-}}

[[Kategorie:Tutorial|Wassereffekt]]

glGenerateMipmap

2014-03-09T10:52:30Z

Glawesome: /* Parameter */

=glGenerateMipmap=
== Name ==
'''glGenerateMipmap''' - erzeugt [[MipMaps]] für die an ''target'' gebundene Textur.

== Delphi-Spezifikation ==
procedure '''glGenerateMipmap'''(''target'' : GLenum);

== Parameter ==
<table border=1 rules=all>
<tr>
<td>''target''</td>
<td>Spezifiziert das Ziel, an das die Textur gebunden ist, zu der MipMaps generiert werden sollen. ''target'' darf einer der folgenden Werte sein:
'''GL_TEXTURE_1D''', '''GL_TEXTURE_2D''', '''GL_TEXTURE_3D''', '''GL_TEXTURE_1D_ARRAY''', '''GL_TEXTURE_2D_ARRAY''', '''GL_TEXTURE_CUBE_MAP''' oder '''GL_TEXTURE_CUBE_MAP_ARRAY'''</td>
</tr>
</table>
 

== Beschreibung ==
'''glGenerateMipmap''' generiert [[MipMaps]] für die Textur, die an ''target'' der aktiven Textureunit (siehe [[glActiveTexture]]) gebunden ist. Dabei werden alle MipMap-Level > 0 neu berechnet und ihr alter Inhalt überschrieben. Die Basistextur (Level 0) bleibt dabei unverändert. Das interne Format der abgeleiteten MipMaps ist das gleiche wie das der Basistextur.

== Hinweise ==
'''glGenerateMipmap''' ist erst ab OpenGL 3.0 verfügbar.

== Fehler ==
'''GL_INVALID_ENUM''' wird generiert, wenn ''target'' keins der oben aufgelisteten Werte ist.

'''GL_INVALID_OPERATION''' wird generiert, wenn ''target'' '''GL_TEXTURE_CUBE_MAP''' ist und die an '''GL_TEXTURE_CUBE_MAP''' gebundene Textur der aktiven Texturunit nicht Cube-vollstänig ist.

== Siehe auch ==
[[glTexImage]], [[glTexParameter]]

[[Kategorie:GL|GenerateMipmap]]
[[Kategorie:GL3|GenerateMipmap]]

glGenerateMipmap

2014-03-09T10:51:32Z

Glawesome: /* Parameter */ Rechtschreibfehler

=glGenerateMipmap=
== Name ==
'''glGenerateMipmap''' - erzeugt [[MipMaps]] für die an ''target'' gebundene Textur.

== Delphi-Spezifikation ==
procedure '''glGenerateMipmap'''(''target'' : GLenum);

== Parameter ==
<table border=1 rules=all>
<tr>
<td>''target''</td>
<td>Spezifiziert das Ziel, an das die Textur gebunden ist, zu der MipMaps generiert werden sollen. ''target'' darf einer der folgenden Werte sein:
'''GL_TEXTURE_1D''', '''GL_TEXTURE_2D''', '''GL_TEXTURE_3D''', '''GL_TEXTURE_1D_ARRAY''', '''GL_TEXTURE_2D_ARRAY''', '''GL_TEXTURE_CUBE_MAP''' oder '''GL_TEXTURE_CUBE_MAP_ARRAY'''</td>
</tr>
</table>

== Beschreibung ==
'''glGenerateMipmap''' generiert [[MipMaps]] für die Textur, die an ''target'' der aktiven Textureunit (siehe [[glActiveTexture]]) gebunden ist. Dabei werden alle MipMap-Level > 0 neu berechnet und ihr alter Inhalt überschrieben. Die Basistextur (Level 0) bleibt dabei unverändert. Das interne Format der abgeleiteten MipMaps ist das gleiche wie das der Basistextur.

== Hinweise ==
'''glGenerateMipmap''' ist erst ab OpenGL 3.0 verfügbar.

== Fehler ==
'''GL_INVALID_ENUM''' wird generiert, wenn ''target'' keins der oben aufgelisteten Werte ist.

'''GL_INVALID_OPERATION''' wird generiert, wenn ''target'' '''GL_TEXTURE_CUBE_MAP''' ist und die an '''GL_TEXTURE_CUBE_MAP''' gebundene Textur der aktiven Texturunit nicht Cube-vollstänig ist.

== Siehe auch ==
[[glTexImage]], [[glTexParameter]]

[[Kategorie:GL|GenerateMipmap]]
[[Kategorie:GL3|GenerateMipmap]]

Mix QuerySpec

2014-03-07T11:13:35Z

Glawesome: /* Siehe auch */ Kategoriefehler

= Mix_QuerySpec =

== Name ==
'''Mix_QuerySpec''' - Gibt Informationen über die aktuellen Audiospezifikationen

== Delphi-Spezifikation ==
function Mix_QuerySpec( var ''frequency'' : Integer; var ''format'' : UInt16; var ''channels'' : Integer ) : Integer;

== Parameter ==

{| border="1" rules="all"
! ''frequency''
| Die Variable, in die später die aktuelle Sample-Rate geschrieben wird.
|-
! ''format''
| Die Variable, in die später das Audioformat geschrieben wird.
|-
! ''channels''
| Die Variable, in die später die Anzahl der Audiokanäle geschrieben wird (1 für Mono, 2 für Stereo)
|}

== Beschreibung ==
Gibt das aktuelle Audioformat, welches gerade von dem geöffneten Gerät verwendet wird. Diese müssen nicht unbedingt mit den Werten, die zuvor an [[Mix_OpenAudio]] übergeben wurden.

== Rückgabewert ==
0 bei einem Fehler. Wenn das Gerät geöffnet ist, dann wird die Anzahl der [[Mix_OpenAudio]] Aufrufe zurückgegeben. Die Werte der Variablen werden bei einem Fehler nicht gesetzt.

== Siehe auch ==
[[Mix_OpenAudio]]

[[Kategorie:SDLMixer|QuerySpec]]

Mix AllocateChannels

2014-03-07T11:12:44Z

Glawesome: /* Siehe auch */ Kategoriefehler

= Mix_AllocateChannels =

== Name ==
'''Mix_AllocateChannels''' - Reserviert Mixerkanäle für die Nutzung durch SDL_Mixer

== Delphi-Spezifikation ==
function '''Mix_AllocateChannels'''( ''numchannels'' : Integer ) : Integer;

== Parameter ==

{| border="1" rules="all"
! ''numchannels''
| Anzahl der Kanäle, die zum Mixen bereitstehen sollten. Eine negative Anzahl wird keine Änderung vornehmen, sondern es wird nur die aktuelle Anzahl zurückgegeben.
|}

== Beschreibung ==
Setzt die Anzahl der Kanäle, die zum Mixen verwendet werden sollen. Diese Funktion kann mehrfach aufgerufen werden, auch wenn gerade Sound abgespielt wird. Wenn ''numchannels'' kleiner als die vorhandene Kanalanzahl, dann werden die höheren Kanäle freigegeben und daher nicht länger abgespielt. Es ist möglicherweise keine so gute Idee, die Anzahl tausendmal in der Sekunde zu ändern.
Wenn Kanäle freigegeben werden, werden die Callbacks die durch [[Mix_ChannelFinished]] gesetzt wurden ausgeführt wenn die Kanäle zum Freigeben angehalten werden.

== Hinweise ==
Wenn null übergeben wird, werden ''alle'' Kanäle freigebenen, Musik wird aber aufgrund der anderen internen Behandlung weiter abgespielt.

== Rückgabewert ==
Gibt die Anzahl der reservierten Kanäle zurück. Dies schlägt niemals fehl... aber eine hohe Anzahl an Kanälen kann Fehler verursachen wenn ein Out-of-Memory auftritt. Hier geht es um ''wirklich'' hohe Werte.

== Siehe auch ==
[[Mix_OpenAudio]]

[[Kategorie:SDLMixer|AllocateChannels]]

SDL GetError

2014-03-07T11:11:04Z

Glawesome: /* Siehe auch */ Kategoriefehler

= SDL_GetError =

== Name ==
'''SDL_GetError''' - Liefert einen String zurück der den letzten aufgetretenen Fehler näher beschreibt. Ab Version 1.0.

== Delphi-Spezifikation ==
function '''SDL_GetError''': PChar;

== Beschreibung ==
'''SDL_GetError''' liefert einen String zurück der den letzten aufgetretenen Fehler näher beschreibt. Besonders bei der Initalisierung sollte überprüft werden, ob angeforderte Ressourcen auch zur Verfügung stehen. Wird statt eines Ergebnisses ein NIL-Wert zurückgegeben, empfiehlt es sich mit '''SDL_GetError''' den aufgetretenen Fehler auszugeben. Dies erleichtert in der Praxis sehr häufig die Diagnose eines Problems.

== Beispiel ==
Wir versuchen künstlich einen Fehler hervorzurufen indem wir als gewünschte Bildschirmauflösung negative Werte angeben. Die daraus resultierende Ausgabe lautet: ''Invalid width or height''
<source lang="pascal">[...]
surface := SDL_SetVideoMode(-800, -600, -32, videoflags);
if not assigned(surface) then
begin
WriteLn(SDL_GetError);
Quit_App;
end;
[...]</source>

== Siehe auch ==
[[glGetError]]

[[Kategorie:SDL|GetError]]
[[Kategorie:SDL2|GetError]]

SDL GetCursor

2014-03-07T11:09:42Z

Glawesome: /* Siehe auch */ Kategoriefehler

= SDL_GetCursor =

== Name ==
'''SDL_GetCursor''' - Gibt den aktuellen Mauszeiger zurück

== Delphi-Spezifikation ==
function '''SDL_GetCursor''': PSDL_Cursor

== Beschreibung ==
Gibt einen Pointer auf den aktuell verwendeten Mauszeiger der Surface zurück.

== Rückgabewert ==
Der Pointer auf den aktuell verwendeten Mauszeiger.

== Siehe auch ==
[[SDL_CreateCursor]], [[SDL_SetCursor]], [[SDL_ShowCursor]]

[[Kategorie:SDL|GetCursor]]