DGL Wiki - Benutzerbeiträge [de]

Link

2012-05-01T23:00:40Z

Damadmax: Link zur OpenStreepMap Texturen Sammlung hinzugefügt

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

= Entwicklung mit OpenGL =

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


== Tutorials ==

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

== OpenGL Funktionen ==

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

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

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

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

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

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

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

== Effekte und Techniken mit OpenGL ==

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

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

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

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

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

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

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

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

= Spieleentwicklung =

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

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

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

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

== Texturen / 2D-Grafiken ==

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

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

=== Sonstige 2D-Grafiken ===

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

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

== Modelle / 3D-Grafiken ==

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

== Sounds ==

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

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

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

Zweifach Parametrisierte Geometrie

2010-10-02T12:43:30Z

Damadmax: Tippfehler im Quelltext korrigiert

== Parametrisierte Geometrie ==
Viele mathematische, geometrische Objekte lassen sich leicht über eine Anzahl Parameter beschreiben, so dass man sie sehr leicht in Polygone oder sonstige Flächenstücke zerlegen kann. Für gewöhnlich ist im 3-dimensionalen Raum das Objekt durch 2 Parameter beschrieben, man hat also eine Funktion φ auf 2 Intervallen I1=[a1,e1], I2=[a2,e2] im 3D-Raum:
φ: I1xI2 -> R3
Setzt man also in φ werte aus I1xI2 ein, so bekommt man einen Punkt auf der Oberfläche des Objektes zurück. Geht man nun systematisch diskrete Punkte auf der Oberfläche durch und fasst sie zu Polygonen zusammen, so erhält man das entsprechende Polygonmodell:

<source lang="pascal">
procedure CreateObject(n: Integer; Phi : Parametrisierung; a1, e1, a2, e2 : Double);
var
i,j: Integer;
theta1, theta2, omega: Double;
begin
for j:=0 to n do
begin
theta1 := ((e1-a1) / n)*j + a1;
theta2 := ((e1-a1) / n)*(j+1) + a1;

glBegin(GL_QUAD_STRIP);
for i:=0 to n do
begin
omega:= ((e2-a2)/n)*i + a2;

glTexCoord2f(i/n,j/n);
glVertex3f(Phi(theta1, omega));

glTexCoord2f(i/n,2*j/n);
glVertex3f(Phi(theta2, omega));
end;
glEnd;
end;
end;</source>

=== Beispiele ===
==== Kugel ====
I1 := [0,π], I2 := [-π, π]
(theta, omega) -> φ(theta, omega) :=
(sin(theta)*cos(omega); sin(theta)*sin(omega); cos(theta) )

==== Torus ====
I1 := I2 := [0,2*π]
0 <= r,R
(theta, omega) -> φ(theta, omega) :=
((R + r*cos(theta))*cos(omega); (R + r*cos(theta))*sin(omega); r*sin(theta))

[[Kategorie:Technik_oder_Algorithmus]]

shader blur

2009-01-19T22:30:23Z

Damadmax: /* Code */

=blur=
Zurück zur [[Shadersammlung]]
{|{{Prettytable_B1}} width=100%
!width=60%|Beschreibung
!width=20%|Autor
!width=20%|Version
|-
|dieser Shader dient dazu ein screenaligned Quad geblurred zu rendern.
|damadmax
|0.1
|}

==Bilder==
{|
|[[Bild:Beispielbild.jpg|framed|Bildbeschreibung]]
|-
|[[Bild:Beispielbild.jpg|framed|Bildbeschreibung]]
|}

''Text und Bilder folgen''

==Beschreibung==
Der Shader macht mehrere Lookups auf die übergebene Textur mit einem -in einem Array- definierten Abstand zueinander.
So kann man auch andere Verteilungen realisieren (z.B. Gauss, Normalverteilung).
Der daraus berechnete Durchschnitt wird dann als Fragment ausgegeben.

Jetzt könnte man natürlich hingehen und sowohl horizontal als auch vertikal in einem Renderdurchgang realisieren. Allerdings wären dass dann bei einer Größe von 5x5 satte 25 Abfragen insgesamt. Mit zwei Durchläufen, verteilt auf horizontal und vertikal, sind es lediglich 10.

Ich habe im nachhinein noch ein paar Verschönerungen am originalen (funktionierenden) Quelltext vorgenommen. Deswegen könnten noch Tipp-/Syntaxfehler vorhanden sein.

==Besondere Vorraussetzungen==
Ich habe diesen Shader mit dem FBO benutzt, weshalb die Auflösung/Texelgröße ein Seitenverhältnis ungleich 1 hat.

==Code==
Vertex Shader
<cpp>
void main(void)
{
gl_TexCoord[0] = gl_MultiTexCoord0;
gl_Position = ftransform();
}
</cpp>

Fragment Shader (vertikal)
<cpp>
uniform sampler2D Texture0;
uniform float strength;

vec2 data[5];
vec2 texelSize = vec2(1.0) / vec2(640.0, 480.0); // resolution hardcoded

int num = 5;

void main()
{
// vec2 data( offset, weight )
data[0] = vec2(-2.0, strength * 0.3);
data[1] = vec2(-1.0, strength * 0.6);
data[2] = vec2( 0.0, strength);
data[3] = vec2( 1.0, strength * 0.6);
data[4] = vec2( 2.0, strength * 0.3);

vec4 blur;
vec2 curPos;
vec4 curColor;

for (int i = 0; i < num; i++)
{
curPos = vec2( gl_TexCoord[0].x, gl_TexCoord[0].y + data[i].x * texelSize.y );
curColor = texture2D( Texture0, curPos ) * data[i].y;
blur += curColor;
}
blur /= float(num); // calc average
gl_FragColor = blur;
}
</cpp>

Fragment Shader (horizontal)
<cpp>
uniform sampler2D Texture0;
uniform float strength;

vec2 data[5];
vec2 texelSize = vec2(1.0) / vec2(640.0, 480.0); // resolution hardcoded

int num = 5;

void main()
{
// vec2 data( offset, weight )
data[0] = vec2(-2.0, strength * 0.3);
data[1] = vec2(-1.0, strength * 0.6);
data[2] = vec2( 0.0, strength);
data[3] = vec2( 1.0, strength * 0.6);
data[4] = vec2( 2.0, strength * 0.3);

vec4 blur;
vec2 curPos;
vec4 curColor;

for (int i = 0; i < num; i++)
{
curPos = vec2( gl_TexCoord[0].x + data[i].x * texelSize.x, gl_TexCoord[0].y );
curColor = texture2D( Texture0, curPos ) * data[i].y;
blur += curColor;
}
blur /= float(num); // calc average
gl_FragColor = blur;
}
</cpp>

shader blur

2009-01-19T21:48:26Z

Damadmax: /* Besondere Vorraussetzungen */

=blur=
Zurück zur [[Shadersammlung]]
{|{{Prettytable_B1}} width=100%
!width=60%|Beschreibung
!width=20%|Autor
!width=20%|Version
|-
|dieser Shader dient dazu ein screenaligned Quad geblurred zu rendern.
|damadmax
|0.1
|}

==Bilder==
{|
|[[Bild:Beispielbild.jpg|framed|Bildbeschreibung]]
|-
|[[Bild:Beispielbild.jpg|framed|Bildbeschreibung]]
|}

''Text und Bilder folgen''

==Beschreibung==
Der Shader macht mehrere Lookups auf die übergebene Textur mit einem -in einem Array- definierten Abstand zueinander.
So kann man auch andere Verteilungen realisieren (z.B. Gauss, Normalverteilung).
Der daraus berechnete Durchschnitt wird dann als Fragment ausgegeben.

Jetzt könnte man natürlich hingehen und sowohl horizontal als auch vertikal in einem Renderdurchgang realisieren. Allerdings wären dass dann bei einer Größe von 5x5 satte 25 Abfragen insgesamt. Mit zwei Durchläufen, verteilt auf horizontal und vertikal, sind es lediglich 10.

Ich habe im nachhinein noch ein paar Verschönerungen am originalen (funktionierenden) Quelltext vorgenommen. Deswegen könnten noch Tipp-/Syntaxfehler vorhanden sein.

==Besondere Vorraussetzungen==
Ich habe diesen Shader mit dem FBO benutzt, weshalb die Auflösung/Texelgröße ein Seitenverhältnis ungleich 1 hat.

==Code==
Vertex Shader
<cpp>
void main(void)
{
gl_TexCoord[0] = gl_MultiTexCoord0;
gl_Position = ftransform();
}
</cpp>

Fragment Shader (vertikal)
<cpp>
uniform sampler2D Texture0;
uniform float strength;

vec2 data[5];
vec2 texelSize = vec2(1.0) / vec2(640.0, 480.0); // resolution hardcoded

int num = 5;

void main()
{
// vec2 data( offset, weight )
data[0] = vec2(-2.0, strength * 0.3);
data[1] = vec2(-1.0, strength * 0.6);
data[2] = vec2( 0.0, strength);
data[3] = vec2( 1.0, strength * 0.6);
data[4] = vec2( 2.0, strength * 0.3);

vec4 blur;
vec2 curPos;
vec4 curColor;

for (int i = 0; i < num; i++)
{
curPos = vec2( gl_TexCoord[0].y + data[i].x * texelSize.y );
curColor = texture2D( Texture0, curPos ) * data[i].y;
blur += curColor;
}
blur /= float(num); // calc average
gl_FragColor = blur;
}
</cpp>

Fragment Shader (horizontal)
<cpp>
uniform sampler2D Texture0;
uniform float strength;

vec2 data[5];
vec2 texelSize = vec2(1.0) / vec2(640.0, 480.0); // resolution hardcoded

int num = 5;

void main()
{
// vec2 data( offset, weight )
data[0] = vec2(-2.0, strength * 0.3);
data[1] = vec2(-1.0, strength * 0.6);
data[2] = vec2( 0.0, strength);
data[3] = vec2( 1.0, strength * 0.6);
data[4] = vec2( 2.0, strength * 0.3);

vec4 blur;
vec2 curPos;
vec4 curColor;

for (int i = 0; i < num; i++)
{
curPos = vec2( gl_TexCoord[0].x + data[i].x * texelSize.x );
curColor = texture2D( Texture0, curPos ) * data[i].y;
blur += curColor;
}
blur /= float(num); // calc average
gl_FragColor = blur;
}
</cpp>

shader blur

2009-01-19T21:47:40Z

Damadmax: /* Beschreibung */

=blur=
Zurück zur [[Shadersammlung]]
{|{{Prettytable_B1}} width=100%
!width=60%|Beschreibung
!width=20%|Autor
!width=20%|Version
|-
|dieser Shader dient dazu ein screenaligned Quad geblurred zu rendern.
|damadmax
|0.1
|}

==Bilder==
{|
|[[Bild:Beispielbild.jpg|framed|Bildbeschreibung]]
|-
|[[Bild:Beispielbild.jpg|framed|Bildbeschreibung]]
|}

''Text und Bilder folgen''

==Beschreibung==
Der Shader macht mehrere Lookups auf die übergebene Textur mit einem -in einem Array- definierten Abstand zueinander.
So kann man auch andere Verteilungen realisieren (z.B. Gauss, Normalverteilung).
Der daraus berechnete Durchschnitt wird dann als Fragment ausgegeben.

Jetzt könnte man natürlich hingehen und sowohl horizontal als auch vertikal in einem Renderdurchgang realisieren. Allerdings wären dass dann bei einer Größe von 5x5 satte 25 Abfragen insgesamt. Mit zwei Durchläufen, verteilt auf horizontal und vertikal, sind es lediglich 10.

Ich habe im nachhinein noch ein paar Verschönerungen am originalen (funktionierenden) Quelltext vorgenommen. Deswegen könnten noch Tipp-/Syntaxfehler vorhanden sein.

==Besondere Vorraussetzungen==
Ich habe diesen Shader mit dem FBO benutzt, weshalb die Auflösung/Texelgröße ein ungleiches Seitenverhältnis hat.

==Code==
Vertex Shader
<cpp>
void main(void)
{
gl_TexCoord[0] = gl_MultiTexCoord0;
gl_Position = ftransform();
}
</cpp>

Fragment Shader (vertikal)
<cpp>
uniform sampler2D Texture0;
uniform float strength;

vec2 data[5];
vec2 texelSize = vec2(1.0) / vec2(640.0, 480.0); // resolution hardcoded

int num = 5;

void main()
{
// vec2 data( offset, weight )
data[0] = vec2(-2.0, strength * 0.3);
data[1] = vec2(-1.0, strength * 0.6);
data[2] = vec2( 0.0, strength);
data[3] = vec2( 1.0, strength * 0.6);
data[4] = vec2( 2.0, strength * 0.3);

vec4 blur;
vec2 curPos;
vec4 curColor;

for (int i = 0; i < num; i++)
{
curPos = vec2( gl_TexCoord[0].y + data[i].x * texelSize.y );
curColor = texture2D( Texture0, curPos ) * data[i].y;
blur += curColor;
}
blur /= float(num); // calc average
gl_FragColor = blur;
}
</cpp>

Fragment Shader (horizontal)
<cpp>
uniform sampler2D Texture0;
uniform float strength;

vec2 data[5];
vec2 texelSize = vec2(1.0) / vec2(640.0, 480.0); // resolution hardcoded

int num = 5;

void main()
{
// vec2 data( offset, weight )
data[0] = vec2(-2.0, strength * 0.3);
data[1] = vec2(-1.0, strength * 0.6);
data[2] = vec2( 0.0, strength);
data[3] = vec2( 1.0, strength * 0.6);
data[4] = vec2( 2.0, strength * 0.3);

vec4 blur;
vec2 curPos;
vec4 curColor;

for (int i = 0; i < num; i++)
{
curPos = vec2( gl_TexCoord[0].x + data[i].x * texelSize.x );
curColor = texture2D( Texture0, curPos ) * data[i].y;
blur += curColor;
}
blur /= float(num); // calc average
gl_FragColor = blur;
}
</cpp>

Diskussion:shader blur

2008-08-12T15:23:32Z

Damadmax: Die Seite wurde neu angelegt: Artikel wird noch bearbeitet. Bitte noch nicht in die Liste aufnehmen. --~~~~

Artikel wird noch bearbeitet. Bitte noch nicht in die Liste aufnehmen.
--[[Benutzer:Damadmax|Damadmax]] 15:23, 12. Aug. 2008 (UTC)

shader blur

2008-08-12T15:10:04Z

Damadmax: Die Seite wurde neu angelegt: =blur= Zurück zur Shadersammlung {|{{Prettytable_B1}} width=100% !width=60%|Beschreibung !width=20%|Autor !width=20%|Version |- |dieser Shader dient dazu ein scree...

=blur=
Zurück zur [[Shadersammlung]]
{|{{Prettytable_B1}} width=100%
!width=60%|Beschreibung
!width=20%|Autor
!width=20%|Version
|-
|dieser Shader dient dazu ein screenaligned Quad geblurred zu rendern.
|damadmax
|0.1
|}

==Bilder==
{|
|[[Bild:Beispielbild.jpg|framed|Bildbeschreibung]]
|-
|[[Bild:Beispielbild.jpg|framed|Bildbeschreibung]]
|}

''Text und Bilder folgen''

==Beschreibung==
Der Shader macht mehrere Lookups auf die übergebene Textur mit einem -in einem Array- definierten Abstand zueinander.
So kann man auch andere Verteilungen realisieren (z.B. Gauss).
Der daraus berechnete Durchschnitt wird dann als Fragment ausgegeben.

Jetzt könnte man natürlich hingehen und sowohl horizontal als auch vertikal in einem Renderdurchgang realisieren. Allerdings wären dass dann bei einer Größe von 5x5 satte 25 Abfragen insgesamt. Mit zwei Durchläufen, verteilt auf horizontal und vertikal, sind es lediglich 10.

Ich habe im nachhinein noch ein paar Verschönerungen am Quelltext vorgenommen. Deswegen könnten noch Tippfehler vorhanden sein.

==Besondere Vorraussetzungen==
Ich habe diesen Shader mit dem FBO benutzt, weshalb die Auflösung/Texelgröße ein ungleiches Seitenverhältnis hat.

==Code==
Vertex Shader
<cpp>
void main(void)
{
gl_TexCoord[0] = gl_MultiTexCoord0;
gl_Position = ftransform();
}
</cpp>

Fragment Shader (vertikal)
<cpp>
uniform sampler2D Texture0;
uniform float strength;

vec2 data[5];
vec2 texelSize = vec2(1.0) / vec2(640.0, 480.0); // resolution hardcoded

int num = 5;

void main()
{
// vec2 data( offset, weight )
data[0] = vec2(-2.0, strength * 0.3);
data[1] = vec2(-1.0, strength * 0.6);
data[2] = vec2( 0.0, strength);
data[3] = vec2( 1.0, strength * 0.6);
data[4] = vec2( 2.0, strength * 0.3);

vec4 blur;
vec2 curPos;
vec4 curColor;

for (int i = 0; i < num; i++)
{
curPos = vec2( gl_TexCoord[0].y + data[i].x * texelSize.y );
curColor = texture2D( Texture0, curPos ) * data[i].y;
blur += curColor;
}
blur /= float(num); // calc average
gl_FragColor = blur;
}
</cpp>

Fragment Shader (horizontal)
<cpp>
uniform sampler2D Texture0;
uniform float strength;

vec2 data[5];
vec2 texelSize = vec2(1.0) / vec2(640.0, 480.0); // resolution hardcoded

int num = 5;

void main()
{
// vec2 data( offset, weight )
data[0] = vec2(-2.0, strength * 0.3);
data[1] = vec2(-1.0, strength * 0.6);
data[2] = vec2( 0.0, strength);
data[3] = vec2( 1.0, strength * 0.6);
data[4] = vec2( 2.0, strength * 0.3);

vec4 blur;
vec2 curPos;
vec4 curColor;

for (int i = 0; i < num; i++)
{
curPos = vec2( gl_TexCoord[0].x + data[i].x * texelSize.x );
curColor = texture2D( Texture0, curPos ) * data[i].y;
blur += curColor;
}
blur /= float(num); // calc average
gl_FragColor = blur;
}
</cpp>

shader verysimple

2008-08-12T14:14:42Z

Damadmax: /* Code */

=verysimple=
Zurück zur [[Shadersammlung]]
{|{{Prettytable_B1}} width=100%
!width=60%|Beschreibung
!width=20%|Autor
!width=20%|Version
|-
|sehr einfacher Shader, welcher eine Textur an Flächen bindet.
|damadmax
|0.1
|}

==Bilder==
{|
|[[Bild:Beispielbild.jpg|framed|Bildbeschreibung]]
|-
|[[Bild:Beispielbild.jpg|framed|Bildbeschreibung]]
|}

''Ich bin mir nicht sicher ob ein einfaches texturiertes Quad als bildliches Beispiel ausreicht?.''

==Beschreibung==
Der Shader ist sehr einfach gehalten. Im Vertex Shader wird lediglich die Standard Transformation durchgeführt und die Texturkoordinate für den Fragment Shader ausgelesen. Der Fragment Shader bannt diesen Texel über einen Lookup in der gebundenden Textur in den Framebuffer.

==Besondere Vorraussetzungen==
keine

==Code==
Vertex Shader
<cpp>
void main(void)
{
gl_TexCoord[0] = gl_MultiTexCoord0;
gl_Position = ftransform();
}
</cpp>

Fragment Shader
<cpp>
uniform sampler2D Texture0;

void main(void)
{
gl_FragColor = texture2D(Texture0, gl_TexCoord[0].xy);
}
</cpp>

shader verysimple

2008-08-10T23:21:50Z

Damadmax: Die Seite wurde neu angelegt: =verysimple= Zurück zur Shadersammlung {|{{Prettytable_B1}} width=100% !width=60%|Beschreibung !width=20%|Autor !width=20%|Version |- |sehr einfacher Shader |damad...

=verysimple=
Zurück zur [[Shadersammlung]]
{|{{Prettytable_B1}} width=100%
!width=60%|Beschreibung
!width=20%|Autor
!width=20%|Version
|-
|sehr einfacher Shader
|damadmax
|0.1
|}

==Bilder==
{|
|[[Bild:Beispielbild.jpg|framed|Bildbeschreibung]]
|-
|[[Bild:Beispielbild.jpg|framed|Bildbeschreibung]]
|}

''Ich bin mir nicht sicher ob ein einfaches texturiertes Quad als bildliches Beispiel ausreicht?.''

==Beschreibung==
Der Shader ist sehr einfach gehalten. Im Vertex Shader wird lediglich die Standard Transformation durchgeführt und die Texturkoordinate für den Fragment Shader ausgelesen. Der Fragment Shader bannt diesen Texel über einen Lookup in der gebundenden Textur in den Framebuffer.

==Besondere Vorraussetzungen==
keine

==Code==
<code>
void main(void)
{
gl_TexCoord[0] = gl_MultiTexCoord0;
gl_Position = ftransform();
}
</code>
<code>
uniform sampler2D Texture0;

void main(void)
{
gl_FragColor = texture2D(Texture0, gl_TexCoord[0].xy);
}
</code>

Benutzer:Damadmax

2008-06-30T23:49:40Z

Damadmax: /* Klassen */

=Über mich=
''BETRETEN DER BAUSTELLE AUF EIGENE GEFAHR!''

=Klassen=

Über die vergangene Zeit sind ein paar Klassen entstanden, die vielleicht für den ein oder anderen nützlich sein könnten.

==Klasse Timing==
Dies ist die Timing-Klasse wie ich sie in allen meiner Testprogramme und Projekte verwende.
<pascal>unit DETiming;

interface

type
TDETiming = class
public
constructor Create;
destructor Destroy; override;
procedure Init;
procedure Tick;

var
FrameTime : single;
FramesPerSecond : single;
FrameTimeInMs : single;
TotalFramesDrawn : int64;
CurrentFrames : integer;
TotalTimeRunning : single;

private var
QPCFreq : int64;
QPCLast : int64;
QPCNow : int64;
end;

implementation

uses
Windows;

constructor TDETiming.Create;
begin
inherited Create;
Init;
end;

destructor TDETiming.Destroy;
begin
inherited Destroy;
end;

procedure TDETiming.Init;
begin
QueryPerformanceCounter(QPCLast);
QueryPerformanceFrequency(QPCFreq);
CurrentFrames := 0;
TotalFramesDrawn := 0;
TotalTimeRunning := 0;
end;

procedure TDETiming.Tick;
begin
QueryPerformanceCounter(QPCNow); // PerfCounter abfragen
TotalFramesDrawn := TotalFramesDrawn + 1; // Selbsterklaerend :)
FrameTimeInMS := (QPCNow - QPCLast) / QPCFreq; // Zeit in Millisekunden pro Frame; fuer Timebased Movement
FrameTime := FrameTimeInMS * 1000.0; // Zeit in Sekunden
TotalTimeRunning := TotalTimeRunning + FrameTime; // Laufzeit in Sekunden
FramesPerSecond := 1.0 / FrameTimeInMs; // Frames pro Sekunde
QPCLast := QPCNow; // PerfCounter speichern
end;</pascal>

==Klasse Profiler==
Den Profiler benutze ich um festzustellen wieviel Zeit in welchem Programmteil vergeht.
Nach jedem Programmabschnitt der untersucht werden soll die Funktion Add mit einem fortlaufenden Wert (0, 1, 2, ...) aufrufen.
Die Funktion AsString liefert die Werte in Prozent.
<pascal>
unit DEProfiler;

interface

type
TDEProfiler = class
public
constructor Create; overload;
constructor Create(AMeasureCount:word); overload;
destructor Destroy; override;
procedure Add(AIndex:word);
function GetSum: int64;
function GetValue(AIndex:word): int64;
function AsString : String; // Hilfsfunktion fuer Logausgabe (in %)
procedure Reset;

private
FLastAddTime : int64;
FSum : int64;
FMeasuredValues : Array of int64;
FSize : word;

procedure Init(ASize:word);
procedure ResetValues;
function CheckRange(AIndex:word): Boolean;
end;

implementation

uses
Windows,
SysUtils;

constructor TDEProfiler.Create;
begin
inherited Create;
Init(8); // Standardmaessig 8 Eintraege
end;

constructor TDEProfiler.Create(AMeasureCount:word);
begin
inherited Create;
Init(AMeasureCount); // Benutzerdefinierte Anzahl Eintraege
end;

destructor TDEProfiler.Destroy;
begin
inherited Destroy;
end;

procedure TDEProfiler.Add(AIndex:word);
var
ActTime : int64;
Diff : int64;
begin
QueryPerformanceCounter( ActTime );
Diff := ActTime - FLastAddTime;
FMeasuredValues[AIndex] := FMeasuredValues[AIndex] + Diff;
FSum := FSum + Diff;
FLastAddTime := ActTime;
end;

function TDEProfiler.GetSum: int64;
begin
Result := FSum;
end;

function TDEProfiler.GetValue(AIndex:word): int64;
begin
if CheckRange(AIndex) then
Result := FMeasuredValues[AIndex]
else
Result := 0;
end;

procedure TDEProfiler.Reset;
begin
ResetValues;
end;

function TDEProfiler.AsString: String;
var
i : word;
begin
for i := Low(FMeasuredValues) to High(FMeasuredValues) do begin
Result := Result + format(' / %d: %f', [ i, 100 / FSum * FMeasuredValues[i] ]);
end;
end;

procedure TDEProfiler.Init(ASize:word);
begin
FSize := ASize;
SetLength(FMeasuredValues, FSize);
QueryPerformanceCounter( FLastAddTime );
ResetValues;
end;

procedure TDEProfiler.ResetValues;
var
i : word;
begin
for i := Low(FMeasuredValues) to High(FMeasuredValues) do begin
FMeasuredValues[i] := 0;
end;
end;

function TDEProfiler.CheckRange(AIndex:word): Boolean;
begin
Result := (Low(FMeasuredValues) <= AIndex) and (High(FMeasuredValues) >= AIndex);
end;

end.
</pascal>

=Testanwendungen=
Die ich in den vergangenen Monaten geschrieben habe.
==Landschaft==

Benutzer:Damadmax

2008-06-30T23:38:39Z

Damadmax: /* Timing Klasse */

=Über mich=
''BETRETEN DER BAUSTELLE AUF EIGENE GEFAHR!''

=Klassen=

Über die vergangene Zeit sind ein paar Klassen entstanden, die vielleicht für den ein oder anderen nützlich sein könnten.

Dies ist die Timing-Klasse wie ich sie in allen meiner Testprogramme und Projekte verwende.

==Klasse Timing==
<pascal>unit DETiming;

interface

type
TDETiming = class
public
constructor Create;
destructor Destroy; override;
procedure Init;
procedure Tick;

var
FrameTime : single;
FramesPerSecond : single;
FrameTimeInMs : single;
TotalFramesDrawn : int64;
CurrentFrames : integer;
TotalTimeRunning : single;

private var
QPCFreq : int64;
QPCLast : int64;
QPCNow : int64;
end;

implementation

uses
Windows;

constructor TDETiming.Create;
begin
inherited Create;
Init;
end;

destructor TDETiming.Destroy;
begin
inherited Destroy;
end;

procedure TDETiming.Init;
begin
QueryPerformanceCounter(QPCLast);
QueryPerformanceFrequency(QPCFreq);
CurrentFrames := 0;
TotalFramesDrawn := 0;
TotalTimeRunning := 0;
end;

procedure TDETiming.Tick;
begin
QueryPerformanceCounter(QPCNow); // PerfCounter abfragen
TotalFramesDrawn := TotalFramesDrawn + 1; // Selbsterklaerend :)
FrameTimeInMS := (QPCNow - QPCLast) / QPCFreq; // Zeit in Millisekunden pro Frame; fuer Timebased Movement
FrameTime := FrameTimeInMS * 1000.0; // Zeit in Sekunden
TotalTimeRunning := TotalTimeRunning + FrameTime; // Laufzeit in Sekunden
FramesPerSecond := 1.0 / FrameTimeInMs; // Frames pro Sekunde
QPCLast := QPCNow; // PerfCounter speichern
end;</pascal>

==Klasse Profiler==
<pascal>
unit DEProfiler;

interface

type
TDEProfiler = class
public
constructor Create;overload;
constructor Create(AMeasureCount:word);overload;
procedure Add(AIndex:word);
function GetSum: int64;
function GetValue(AIndex:word): int64;
function AsString : String; // Hilfsfunktion fuer Logausgabe (in %)
destructor Destroy; override;

private
FLastAddTime : int64;
FSum : int64;
FMeasuredValues : Array of int64;
FSize : word;

procedure Init(ASize:word);
function CheckRange(AIndex:word): Boolean;
end;

implementation

uses
Windows;

constructor TDEProfiler.Create;
begin
inherited Create;
Init(32); // Standardmaessig 32 Eintraege
end;

constructor TDEProfiler.Create(AMeasureCount:word);
begin
inherited Create;
Init(AMeasureCount); // Benutzerdefinierte Anzahl Eintraege
end;

procedure TDEProfiler.Init(ASize:word);
begin
FSize := ASize;
SetLength(FMeasuredValues, FSize);
QueryPerformanceCounter( FLastAddTime );
end;

procedure TDEProfiler.Add(AIndex:word);
var
ActTime : int64;
Diff : int64;
begin
QueryPerformanceCounter( ActTime );
Diff := ActTime - FLastAddTime;
FMeasuredValues[AIndex] := FMeasuredValues[AIndex] + Diff;
FSum := FSum + Diff;
FLastAddTime := ActTime;
end;

function TDEProfiler.GetSum: int64;
begin
Result := FSum;
end;

function TDEProfiler.GetValue(AIndex:word): int64;
begin
if CheckRange(AIndex) then
Result := FMeasuredValues[AIndex]
else
Result := 0;
end;

function TDEProfiler.CheckRange(AIndex:word): Boolean;
begin
Result := (Low(FMeasuredValues) <= AIndex) and (High(FMeasuredValues) >= AIndex);
end;

function TDEProfiler.AsString: String;
var
i : integer;
begin
for i := Low(FMeasuredValues) to High(FMeasuredValues) do begin
Result := Result + format(' / %d: %f', [ i, 100 / FSum * FMeasuredValues[i] ]);
end;
end;

destructor TDEProfiler.Destroy;
begin
inherited Destroy;
end;

end.
</pascal>

=Testanwendungen=
Die ich in den vergangenen Monaten geschrieben habe.
==Landschaft==

Benutzer:Damadmax

2008-06-30T23:38:23Z

Damadmax: /* Klassen */

=Über mich=
''BETRETEN DER BAUSTELLE AUF EIGENE GEFAHR!''

=Klassen=

Über die vergangene Zeit sind ein paar Klassen entstanden, die vielleicht für den ein oder anderen nützlich sein könnten.

Dies ist die Timing-Klasse wie ich sie in allen meiner Testprogramme und Projekte verwende.

==Timing Klasse==
<pascal>unit DETiming;

interface

type
TDETiming = class
public
constructor Create;
destructor Destroy; override;
procedure Init;
procedure Tick;

var
FrameTime : single;
FramesPerSecond : single;
FrameTimeInMs : single;
TotalFramesDrawn : int64;
CurrentFrames : integer;
TotalTimeRunning : single;

private var
QPCFreq : int64;
QPCLast : int64;
QPCNow : int64;
end;

implementation

uses
Windows;

constructor TDETiming.Create;
begin
inherited Create;
Init;
end;

destructor TDETiming.Destroy;
begin
inherited Destroy;
end;

procedure TDETiming.Init;
begin
QueryPerformanceCounter(QPCLast);
QueryPerformanceFrequency(QPCFreq);
CurrentFrames := 0;
TotalFramesDrawn := 0;
TotalTimeRunning := 0;
end;

procedure TDETiming.Tick;
begin
QueryPerformanceCounter(QPCNow); // PerfCounter abfragen
TotalFramesDrawn := TotalFramesDrawn + 1; // Selbsterklaerend :)
FrameTimeInMS := (QPCNow - QPCLast) / QPCFreq; // Zeit in Millisekunden pro Frame; fuer Timebased Movement
FrameTime := FrameTimeInMS * 1000.0; // Zeit in Sekunden
TotalTimeRunning := TotalTimeRunning + FrameTime; // Laufzeit in Sekunden
FramesPerSecond := 1.0 / FrameTimeInMs; // Frames pro Sekunde
QPCLast := QPCNow; // PerfCounter speichern
end;</pascal>

==Klasse Profiler==
<pascal>
unit DEProfiler;

interface

type
TDEProfiler = class
public
constructor Create;overload;
constructor Create(AMeasureCount:word);overload;
procedure Add(AIndex:word);
function GetSum: int64;
function GetValue(AIndex:word): int64;
function AsString : String; // Hilfsfunktion fuer Logausgabe (in %)
destructor Destroy; override;

private
FLastAddTime : int64;
FSum : int64;
FMeasuredValues : Array of int64;
FSize : word;

procedure Init(ASize:word);
function CheckRange(AIndex:word): Boolean;
end;

implementation

uses
Windows;

constructor TDEProfiler.Create;
begin
inherited Create;
Init(32); // Standardmaessig 32 Eintraege
end;

constructor TDEProfiler.Create(AMeasureCount:word);
begin
inherited Create;
Init(AMeasureCount); // Benutzerdefinierte Anzahl Eintraege
end;

procedure TDEProfiler.Init(ASize:word);
begin
FSize := ASize;
SetLength(FMeasuredValues, FSize);
QueryPerformanceCounter( FLastAddTime );
end;

procedure TDEProfiler.Add(AIndex:word);
var
ActTime : int64;
Diff : int64;
begin
QueryPerformanceCounter( ActTime );
Diff := ActTime - FLastAddTime;
FMeasuredValues[AIndex] := FMeasuredValues[AIndex] + Diff;
FSum := FSum + Diff;
FLastAddTime := ActTime;
end;

function TDEProfiler.GetSum: int64;
begin
Result := FSum;
end;

function TDEProfiler.GetValue(AIndex:word): int64;
begin
if CheckRange(AIndex) then
Result := FMeasuredValues[AIndex]
else
Result := 0;
end;

function TDEProfiler.CheckRange(AIndex:word): Boolean;
begin
Result := (Low(FMeasuredValues) <= AIndex) and (High(FMeasuredValues) >= AIndex);
end;

function TDEProfiler.AsString: String;
var
i : integer;
begin
for i := Low(FMeasuredValues) to High(FMeasuredValues) do begin
Result := Result + format(' / %d: %f', [ i, 100 / FSum * FMeasuredValues[i] ]);
end;
end;

destructor TDEProfiler.Destroy;
begin
inherited Destroy;
end;

end.
</pascal>

=Testanwendungen=
Die ich in den vergangenen Monaten geschrieben habe.
==Landschaft==

Benutzer:Damadmax

2008-06-30T23:36:32Z

Damadmax: /* Klassen */

Benutzer:Damadmax

2008-06-30T23:32:18Z

Damadmax:

glGet

2008-04-04T14:40:59Z

Damadmax: /* GL_FOG_HINT */ Tippfehler

= Funktionsname =

== Name ==

'''glGet''' - glGet liefert einen oder mehrere Werte eines ausgewählten Parameters zurück

== Delphi-Spezifikation ==

procedure '''glGetBooleanv'''('''pname''': TGLenum; '''params''': PGLboolean);
procedure '''glGetDoublev'''('''pname''': TGLenum; '''params''': PGLdouble);
procedure '''glGetFloatv'''('''pname''': TGLenum; '''params''': PGLfloat);
procedure '''glGetIntegerv'''('''pname''': TGLenum; '''params''': PGLint);
 

== Parameter ==

<table border=1>
<tr>
<td>''pname''</td>
<td>Legt fest von welchem Parameter der Wert zurückgeliefert werden soll. 
In nachfolgender Liste werden die akzeptierten Werte aufgelistet.</td>
</tr>
<tr>
<td>''params''</td>
<td>Enthält den Rückgabewert der gefordert wurde.</td>
</tr>
</table>

== Beschreibung ==

Folgende Werte werden für den Parameter ''pname'' akzeptiert:

===A===
====GL_ACCUM_ALPHA_BITS====

: ''params'' liefert die Anzahl der Bits zurück, die einem Pixel des [[accumulation buffer]]s für seinen '''Alpha'''-Anteil zur Verfügung steht.

====GL_ACCUM_BLUE_BITS====

: ''params'' liefert die Anzahl der Bits zurück, die einem Pixel des [[accumulation buffer]]s für seinen '''Blau'''-Anteil zur Verfügung steht.

====GL_ACCUM_CLEAR_VALUE====

: ''params'' liefert die '''4''' Farbwerte(Rot,Grün,Blau,Alpha) zurück aus dennen sich die Löschfarbe für den [[accumulation buffer]] zusammensetzt.(Kann mit [[glClearAccum]] gesetzt werden)

====GL_ACCUM_GREEN_BITS====

: ''params'' liefert die Anzahl der Bits zurück, die einem Pixel des [[accumulation buffer]]s für seinen '''Grün'''-Anteil zur Verfügung steht.

====GL_ACCUM_RED_BITS====

: ''params'' liefert die Anzahl der Bits zurück, die einem Pixel des [[accumulation buffer]]s für seinen '''Rot'''-Anteil zur Verfügung steht.

====GL_ALPHA_BIAS====

: ''params'' liefert den Alpha BIAS Faktor welcher bei Pixel Transfer genutz wird. Siehe [[glPixelTransfer]]

====GL_ALPHA_BITS====

: ''params'' liefert die Anzahl der Bits zurück, die einem Pixel des [[Farbpuffer]]s für seinen '''Alpha'''-Anteil zur Verfügung steht.

====GL_ALPHA_SCALE====

: ''params'' liefert den Salierungs Wert für Alpha beim Pixel Transfer an

====GL_ALPHA_TEST====

: ''params'' liefert einen einzelnen Booleanwert der angibt, ob die Überprüfung des Alphas durch [[glEnable]] aktiviert wurde oder nicht. Siehe [[glPixelTransfer]]

====GL_ALPHA_TEST_FUNC====

: ''params'' liefert den symbolischen Namen der Alphatest-Funktion.

====GL_ALPHA_TEST_REF====

: ''params'' liefert den Wert zurück der mit [[glAlphaFunc]] im Parameter ''ref'' eingestellt wurde. Wird ein integer abgefragt, wird der Rückgabewert direkt von der internen Fließkomma Representation auf das Intervall [-1.0..1.0] abgebildet. Dies geschieht so, dass der kleinstmögliche Wert = -1.0 und der größtmögliche Wert = 1.0 wird.

====GL_ATTRIB_STACK_DEPTH====

: ''params'' liefert einen Wert zurück, die Tiefe des Attributstacks. Wenn dieser leer ist wird null zurückgegeben. (siehe [[glPushAttrib]])

====GL_AUTO_NORMAL====

:''params'' gibt als einzelnen booleanschen Wert an, ob die 2D-Oberflächenevaluation automatische Oberflächennormalen generiert. Siehe [[glMap2]].

====GL_AUX_BUFFERS====

: ''params'' liefert einen Wert zurück, die Anzahl der Hilfsfarbpuffer.

===B===

====GL_BLEND====

: ''params'' liefert einen Booleanwert zurück, der angibt ob [[Blending]] aktiviert ist. (siehe auch [[glBlendFunc]])

====GL_BLEND_COLOR====

:''params'' liefert viert Werte zurück. Den roten, grünen, blauen und alpha-Anteil der aktuellen Blendfarbe zurück. Siehe [[glBlendColor]].

====GL_BLEND_DST====

:''params'' liefert als einzelnen Wert die symbolische Konstante zurück, die die Ziel-Blendfunktion identifiziert. Siehe [[glBlendFunc]].

====GL_BLEND_DST_ALPHA====

:''params'' liefert als einzelnen Wert die symbolische Konstante zurück, die die Ziel-Blendfunktion für den Alphawert identifiziert. Siehe [[glBlendFuncSeparate]].

====GL_BLEND_DST_RGB====

:''params'' liefert als einzelnen Wert die symbolische Konstante zurück, die die Ziel-Blendfunktion für Rot, Grün und Blau identifiziert. Siehe [[glBlendFuncSeparate]].

====GL_BLEND_EQUATION====

:''params'' liefert als einzelnen Wert die symbolische Konstante zurück, die die Blending-Gleichung angibt. Siehe [[glBlendEquation]].

====GL_BLEND_SRC====

: ''params'' liefert einen Wert zurück, den symbolischen Name der Quellblendfunktion. (siehe [[glBlendFunc]])

====GL_BLEND_SRC_ALPHA====

:''params'' liefert als einzelnen Wert die symbolische Konstante zurück, die die Quell-Blendfunktion für den Alphawert identifiziert. Siehe [[glBlendFuncSeparate]].

====GL_BLEND_SRC_RGB====

:''params'' liefert als einzelnen Wert die symbolische Konstante zurück, die die Quell-Blendfunktion für Rot, Grün und Blau identifiziert. Siehe [[glBlendFuncSeparate]].

====GL_BLUE_BIAS====

:''params'' liefert in einem Wert die Verschiebung für den blauen Farbwert während eines Pixeltransfers zurück. Siehe [[glPixelTransfer]].

====GL_BLUE_BITS====

:''params'' liefert als einzelnen Wert die Anzahl der Bits für den blauen Farbanteil eines Farbpuffer zurück.

====GL_BLUE_SCALE====

:''params'' liefert in einem Wert die Skalierung für den blauen Farbwert während eines Pixeltransfers zurück. Siehe [[glPixelTransfer]].

===C===

====GL_CLIP_PLANEi====

: ''params'' liefert einen Booleanwert zurück, der angibt ob die spezielle (i-te) Clipping Plane aktiviert ist. (siehe [[glClipPlane]])

====GL_COLOR_ARRAY_SIZE====

:''params'' liefert als einzelnen Parameter die Anzahl der Komponenten pro Element im Farben-Array zurück. Siehe [[glColorPointer]].

====GL_COLOR_ARRAY_STRIDE====

:''params'' liefert als einzelnen Parameter den Byteversatz zwischen den aufeinander folgenden Elementen in einem Farben-Array zurück. Siehe [[glColorPointer]].

====GL_COLOR_ARRAY_TYPE====

:''param'' liefert als einzelnen Wert den Datentyp für die Komponenten in einem Farben-Array zurück. Siehe [[glColorPointer]].

====GL_COLOR_CLEAR_VALUE====

: ''params'' liefert vier Werte zurück welche die aktuelle Farbe angeben mit welcher der ColorBuffer geleert wird. (siehe [[glClearColor]])

====GL_COLOR_MATERIAL====

: ''params'' liefert einen einzelnen Booleanwert zurück, der angibt ob ein oder mehrere Materialparameter die aktuelle Farbe beeinflussen bzw. aktiv sind. (siehe [[glColorMaterial]])

====GL_COLOR_MATERIAL_FACE====

: ''params'' liefert eine symbolische Konstante die angibt welche Materialien einen Parameter besitzen, der die aktuelle Farbe beeinflusst. (siehe [[glColorMaterial]])

====GL_COLOR_MATERIAL_PARAMETER====

: ''params'' liefert eine symbolische Konstante die angibt welche Materialparameter die aktuelle Farbe beeinflussen. (siehe [[glColorMaterial]])

====GL_COLOR_WRITEMASK====

: ''params'' liefert vier Booleanwerte: Die rot, grün, blau und alpha Parameter die angeben, ob die jeweilige Farbkomponente in den Farbpuffer geschrieben werden kann. (siehe [[glColorMask]])

====GL_CULL_FACE====

: ''params'' liefert einen Booleanwert zurück, der angibt ob [[Backfaceculling|Polygoneculling]] aktiv ist. (siehe [[glCullFace]])

====GL_CULL_FACE_MODE====

: ''params'' liefert einen Wert zurück, den symbolischen Namen der Flächen, die vom Zeichnen ausgeschlossen werden sollen.

====GL_CURRENT_COLOR====

: ''params'' liefert vier Werte: Der Rot-, Grün-, Blau-, und Alphafarbanteil der aktuellen Farbe. Werden integer-Werte abgefragt, wird der Rückgabewert direkt von der internen Fließkomma Representation auf das Intervall [-1.0..1.0] abgebildet. Dies geschieht so, dass der kleinstmögliche Wert = -1.0 und der größtmögliche Wert = 1.0 wird. (siehe [[glColor]])

====GL_CURRENT_FOG_COORD====
: ''params'' liefert einen Wert zurück, die aktuelle Nebelkoordinate. (siehe [[glFogCoord]])

====GL_CURRENT_INDEX====

: ''params'' liefert einen Wert zurück, den Index der aktuellen Farbe. (siehe [[glIndex]])

====GL_CURRENT_NORMAL====

: ''params'' liefert drei Werte zurück, die x, y und z-Koordinate der aktuellen Normale. Werden integer-Werte abgefragt, wird der Rückgabewert direkt von der internen Fließkomma Representation auf das Intervall [-1.0..1.0] abgebildet. Dies geschieht so, dass der kleinstmögliche Wert = -1.0 und der größtmögliche Wert = 1.0 wird.

====GL_CURRENT_PROGRAM====
: ''params'' liefert das handle eines aktuellen Shaders zurück. Diese Konstante ist erst ab OpenGL 2.0 verfügbar. Die Aufgabe dieser Konstante wurde früher von [[glGetHandleARB]] übernommen.

====GL_CURRENT_RASTER_COLOR====

: ''params'' liefert vier Werte: Der Rot-, Grün-, Blau-, und Alphafarbanteil der aktuellen Rasterposition. Werden integer-Werte abgefragt, wird der Rückgabewert direkt von der internen Fließkomma Representation auf das Intervall [-1.0..1.0] abgebildet. Dies geschieht so, dass der kleinstmögliche Wert = -1.0 und der größtmögliche Wert = 1.0 wird. (siehe [[glRasterPos]])

====GL_CURRENT_RASTER_DISTANCE====

: ''params'' liefert einen Wert, die Distanz von der Betrachterposition (dem Auge) zur aktuellen Rasterposition. (siehe [[glRasterPos]])

====GL_CURRENT_RASTER_INDEX====

: ''params'' liefert einen Wert, den Farbindex der aktuellen Rasterposition. (siehe [[glRasterpos]])

====GL_CURRENT_RASTER_POSITION====

: ''params'' liefert vier Werte: Die x, y, z und w Komponenten der aktuellen Rasterposition. x, y und z sind dabei in Fensterkoordinaten, w in Clipkoordinaten angegeben. (siehe [[glRasterpos]])

====GL_CURRENT_RASTER_TEXTURE_COORDS====

:''params'' liefert 4 Werte: Die aktellen s, t, r und q Texturkoordinaten. Siehe [[glTexCoord]].

====GL_CURRENT_RASTER_POSITION_VALID====

: ''params'' liefert einen einzelnen Booleanwert der angibt, ob die aktuelle Rasterposition gültig ist. (siehe [[glRasterPos]])

====GL_CURRENT_TEXTURE_COORDS====

: ''params'' liefert vier Werte: Die s, t, r und q Komponente der aktuellen Texturkoordinaten.

===D===

====GL_DEPTH_BIAS====

: ''params'' liefert als einzelnen (Fließkomma)Wert den Tiefenverschiebungsfaktor (Depth Bias) zurück, der beim Pixeltransfer verwendet wird. Siehe [[glPixelTransfer]].

====GL_DEPTH_BITS====

: ''params'' liefert als einzelnen (Ganzzahl)Wert die Anzahl der Bitflächen (Bittiefe) des Tiefenpuffers zurück.

====GL_DEPTH_CLEAR_VALUE====

: ''params'' liefert den Wert zurück, mit dem der Tiefenpuffer gelöscht wird. Falls als Integerwert angefordert, wird die Fließkommarepräsentation linear angepasst, so dass 1 dem größten positiven Ganzzahlwert und -1 dem größten negativen Ganzzahlwert entspricht. Siehe [[glClearDepth]].

====GL_DEPTH_FUNC====

: ''params'' gibt als einzelnen Wert eine symbolische Konstante zurück, die den aktuellen Tiefenvergleich angibt. Siehe [[glDepthFunc]].

====GL_DEPTH_RANGE====

: ''params'' liefert in zwei Werten das nahe und ferne Limit für den Tiefenpuffer zurück. Falls als Integerwert angefordert, wird die Fließkommarepräsentation linear angepasst, so dass 1 dem größten positiven Ganzzahlwert und -1 dem größten negativen Ganzzahlwert entspricht. Siehe [[glDepthRange]].

====GL_DEPTH_SCALE====

: ''params'' liefert einen Wert, den Tiefenskalierungsfaktor, welcher während des Pixeltransfers benutzt wird. (siehe [[glPixelTransfer]])

====GL_DEPTH_TEST====

: ''params'' liefert einen Booleanwert der angibt, ob der Tiefentest für Fragmente durchgeführt wird oder nicht. (siehe [[glDepthFunc]], [[glDepthRange]] sowie [[Tiefentest]] )

====GL_DEPTH_WRITEMASK====

: ''params'' liefert einen Booleanwert der angibt, ob der Tiefenpuffer beschrieben werden kann.

====GL_DITHER====

: ''params'' liefert als einzelnen boolschen Wert zurück, ob das Dithern von Fragmentfarben und -indizes aktiv ist.

====GL_DOUBLEBUFFER====

: ''params'' liefert einen Booleanwert zurück der angibt, ob [[Doppelpufferung|Doublebuffering]] unterstützt wird.

====GL_DRAW_BUFFER====

: ''params'' liefert einen Wert, eine symbolische Konstante, die angibt, in welchen Buffer gerade gezeichnet wird. (siehe [[glDrawBuffer]])

===E===

====GL_EDGE_FLAG====

: ''params'' gibt in einem einzelnen boolschen Wert an, ob das aktuelle Kantenflag ''wahr'' oder ''falsch'' ist. Siehe [[glEdgeFlag]].

====GL_EDGE_FLAG_ARRAY_STRIDE====

:''params'' liefert als einzelnen Parameter den Byteversatz zwischen den aufeinander folgenden Elementen in einem Kantenflag-Array zurück. Siehe [[glEdgeFlagPointer]].

===F===

====GL_FOG====

: ''params'' gibt als einzelnen boolschen Wert an, ob Nebel aktiviert ist. Siehe [[glFog]].

====GL_FOG_COLOR====

: ''params'' liefert vier Werte zurück, den Rot-, Grün-, Blauanteil des Nebels, sowie den Alphawert. Wenn als Integerwert angefordert, wird der Fließkommabereich von -1..1 auf den gesamten Integerbereich abgebildet. Siehe [[glFog]].

====GL_FOG_DENSITY====

: ''params'' gibt als einzelnen Wert die dichte des Nebels zurück. Siehe [[glFog]].

====GL_FOG_END====

: ''params'' gibt als einzelnen Wert den End-Faktor für die lineare Nebelgleichen an. Siehe [[glFog]].

====GL_FOG_HINT====

: ''params'' gibt als einzelnen Wert eine symbolische Konstante zurück, die den Modus für den Nebelhinweis angibt. Siehe [[glFog]].

====GL_FOG_INDEX====

: ''params'' liefert als einzelnen Wert den Farbindex des Nebels zurück. Siehe [[glFog]].

====GL_FOG_MODE====

: ''params'' liefert als symbolische Konstante wie aktuelle Nebelgleichung zurück. Siehe [[glFog]].

====GL_FOG_START====

: ''params'' gibt als einzelnen Wert den Start-Faktor für die lineare Nebelgleichen an. Siehe [[glFog]].

====GL_FRONT_FACE====

: ''params'' liefert eine symbolische Konstante, die angibt ob entweder Seiten mit Polygonwicklung im Uhrzeigersinn, oder mit Polygonwicklung gegen den Uhrzeigersinn, Vorderseiten darstellen. Siehe [[glFrontFace]].

===G===

====GL_GENERATE_MIPMAP_HINT====

: ''params'' liefert als symbolische Konstanten den Modus für den Hinweis zur Erstellung von [[MipMaps]] zurück. Siehe [[glHint]].

====GL_GREEN_BIAS====

: ''params'' liefert als einzelnen Wert den Verschiebungsfaktor für Grünwerte während eines Pixeltransfers zurück.

====GL_GREEN_BITS====

: ''params'' liefert als einzelnen Wert die Zahl der Bitflächen (Bittiefe) für Grün eines Farbpuffers zurück.

====GL_GREEN_SCALE====

: ''params'' liefert als einzelnen Wert den Skalierungsfaktor für Grünwerte zurück, der während des Pixeltransfers angewandt wird. Siehe [[glPixelTransfer]].

===I===

====GL_INDEX_ARRAY_STRIDE====

:''params'' liefert als einzelnen Parameter den Byteversatz zwischen den aufeinander folgenden Elementen in einem Farbindex-Array zurück. Siehe [[glIndexPointer]].

====GL_INDEX_ARRAY_TYPE====

:''param'' liefert als einzelnen Wert den Datentyp der Komponenten in einem Farbindex-Array zurück. Siehe [[glIndexPointer]].

====GL_INDEX_BITS====

: ''params'' liefert als einzelnen Wert die Zahl der Bitflächen eines Farbindexpuffers zurück.

====GL_INDEX_CLEAR_VALUE====

: ''params'' liefert einen Wert zurück, den Index der Farbe mit dem der ColorBuffer geleert wird. Siehe [[glClearIndex]].

====GL_INDEX_MODE====

: ''params'' liefert einen Booleanwert zurück, der anzeigt ob sich OpenGL im Indexmodus(true) oder RGBA-Modus(false) befindet.

====GL_INDEX_OFFSET====

: ''params'' liefert als einzelnen Wert den Versatz zurück, der zu Farb- und Stencilindizes während eines Pixeltransfers addiert wird. Siehe [[glPixelTransfer]].

====GL_INDEX_SHIFT====

: ''params'' liefert einen einzelnen Wert zurück, um den Farb- und Stencilindizes während eines Pixeltransfers verschoben werden. Siehe [[glPixelTransfer]].

====GL_INDEX_WRITEMASK====

: ''params'' liefert als einzelnen Wert eine Maske zurück, die angibt welche Bitflächen eines jeden Farbindexpuffers beschrieben werden können. Siehe [[glIndexMask]].

===L===

====GL_LIGHTi====

: ''params'' liefert einen Booleanwert zurück, der anzeigt ob das entsprechende (i-te)Licht aktiviert ist oder nicht. Siehe [[glLight]] und [[glLightModel]].

====GL_LIGHTING====

: ''params'' liefert einen Booleanwert zurück, der anzeigt ob die OpenGL Beleuchtung aktiviert ist. Siehe [[glLightModel]].

====GL_LIGHT_MODEL_AMBIENT====

: ''params'' liefert vier Werte zurück, die Rot-, Grün-, Blau- und Alphakomponente der ambienten Intensität für die komplette Szene. Wenn als Integerwert angefordert, wird der Fließkommabereich von -1..1 auf den gesamten Integerbereich abgebildet. Siehe [[glLightModel]].

====GL_LIGHT_MODEL_COLOR_CONTROL====

: ''params'' liefert als einzelnen Wert den Farbkontrollwert zurück. Siehe [[glLightModel]].

====GL_LIGHT_MODEL_LOCAL_VIEWER====

: ''params'' gibt als boolenschen Wert an, ob spekulative Reflektionsberechnungen den Betrachter als lokal zur Szene ansehen. Siehe [[glLightModel]].

====GL_LIGHT_MODEL_TWO_SIDE====

: ''params'' gibt als boolenschen Wert an, ob für die Beleuchtung von Vorder- und Rückseite eines Polygons unterschiedliche Materialien genutzt werden. Siehe [[glLightModel]].

====GL_LINE_SMOOTH_HINT====

: ''params'' gibt als boolenschen Wert an, ob Kantenglättung für Linien aktiviert ist. Siehe [[glLineWidth]].

====GL_LINE_SMOOTH_HINT====

: ''params'' liefert als symbolische Konstante den Hinweis für die Kantenglättung von Linien zurück. Siehe [[glHint]].

====GL_LINE_STIPPLE====

: ''params'' gibt als boolenschen Wert an, ob Musterung für Linien aktiviert ist. Siehe [[glLineStipple]].

====GL_LINE_STIPPLE_PATTERN====

: ''params'' liefert als einzelnen 16-Bit Wert das Linienmuster zurück. Siehe [[glLineStipple]].

====GL_LINE_STIPPLE_REPEAT====

: ''params'' liefert als einzelnen Wert den Faktor für die Musterwiederholung von Linien zurück. Siehe [[glLineStipple]].

====GL_LINE_WIDTH====

: ''params'' liefert als einzelnen Wert die aktuelle Liniendicke zurück. Siehe [[glLineWidth]].

====GL_LINE_WIDTH_GRANULARITY====

: ''params'' liefert als einzelnen Wert den unterstützten Differenzwert zwischen zwei Linienbreiten zurück. Siehe [[glLineWidth]].

====GL_LINE_WIDTH_RANGE====

: ''params'' liefert zwei Werte zurück. Zuerst die kleinste, und dann die größte unterstützte Dicke für kantengeglättete Linien. Siehe [[glLineWidth]].

====GL_LIST_BASE====

: ''params'' liefert als einzelnen Wert den Versatz zurück, der auf alle Displaylistennamen die an [[glCallLists]] übergeben werden, addiert wird. Siehe [[glListBase]].

====GL_LIST_INDEX====

: ''params'' liefert als einzelnen Wert den Namen der momentan in Erstellung befindlichen Displayliste zurück. Wird gerade keine Displayliste erstellt, wird 0 zurückgegeben. Siehe [[glNewList]].

====GL_LIST_MODE====

: ''params'' liefert als symbolische Konstante den Erstellungsmodus der gerade in Erstellung befindlichen Displayliste zurück. Siehe [[glNewList]].

====GL_LOGIC_OP====

: ''params'' gibt als boolenschen Wert an, ob Fragmentindizes unter Nutzung eines logischen Operation in den Farbpuffer eingebunden werden. Siehe [[glLogicOp]].

====GL_LOGIC_OP_MODE====

: ''params'' liefert als symbolische Konstante den momentan gewählten Modus für logische Operationen zurück. Siehe [[glLogicOp]].

===M===

====GL_MAP1_COLOR_4====

: ''params'' liefert als einzelnen boolschen Wert zurück ob 1D-Evaluation Farbwerte generiert. Siehe [[glMap1]].

====GL_MAP1_GRID_DOMAIN====

: ''params'' liefert zwei Werte zurück, die Endpunkte der Gitterdomäne der 1D-Map. Siehe [[glMapGrid]].

====GL_MAP1_GRID_SEGMENTS====

: ''params'' liefert als einzelnen Wert die Anzahl der Unterteilungen der Gitterdomäne der 1D-Map zurück. Siehe [[glMapGrid]].

====GL_MAP1_INDEX====

: ''params'' liefert als einzelnen boolschen Wert zurück ob 1D-Evaluation Farbindizes generiert. Siehe [[glMap1]].

====GL_MAP1_NORMAL====

: ''params'' liefert als einzelnen boolschen Wert zurück ob 1D-Evaluation Normalen generiert. Siehe [[glMap1]].

====GL_MAP1_TEXTURE_COORD_1====

: ''params'' liefert als einzelnen boolschen Wert zurück ob 1D-Evaluation 1D-Texturkoordinaten generiert. Siehe [[glMap1]].

====GL_MAP1_TEXTURE_COORD_2====

: ''params'' liefert als einzelnen boolschen Wert zurück ob 1D-Evaluation 2D-Texturkoordinaten generiert. Siehe [[glMap1]].

====GL_MAP1_TEXTURE_COORD_3====

: ''params'' liefert als einzelnen boolschen Wert zurück ob 1D-Evaluation 3D-Texturkoordinaten generiert. Siehe [[glMap1]].

====GL_MAP1_TEXTURE_COORD_4====

: ''params'' liefert als einzelnen boolschen Wert zurück ob 1D-Evaluation 4D-Texturkoordinaten generiert. Siehe [[glMap1]].

====GL_MAP1_VERTEX_3====

: ''params'' liefert als einzelnen boolschen Wert zurück ob 1D-Evaluation 3D-Vertexkoordinaten generiert. Siehe [[glMap1]].

====GL_MAP1_VERTEX_4====

: ''params'' liefert als einzelnen boolschen Wert zurück ob 1D-Evaluation 4D-Vertexkoordinaten generiert. Siehe [[glMap1]].

====GL_MAP2_COLOR_4====

: ''params'' liefert als einzelnen boolschen Wert zurück ob 2D-Evaluation Farbwerte generiert. Siehe [[glMap2]].

====GL_MAP2_GRID_DOMAIN====

: ''params'' liefert vier Werte zurück, die Endpunkte der Gitterdomäne der 2D-Map in i und j Richtung. Siehe [[glMapGrid]].

====GL_MAP2_GRID_SEGMENTS====

: ''params'' liefert zwei Werte, die Anzahl der Unterteilungen der Gitterdomäne der 2D-Map zurück in i und j Richtung. Siehe [[glMapGrid]].

====GL_MAP2_INDEX====

: ''params'' liefert als einzelnen boolschen Wert zurück ob 2D-Evaluation Farbindizes generiert. Siehe [[glMap2]].

====GL_MAP2_NORMAL====

: ''params'' liefert als einzelnen boolschen Wert zurück ob 2D-Evaluation Normalen generiert. Siehe [[glMap2]].

====GL_MAP2_TEXTURE_COORD_1====

: ''params'' liefert als einzelnen boolschen Wert zurück ob 2D-Evaluation 1D-Texturkoordinaten generiert. Siehe [[glMap2]].

====GL_MAP2_TEXTURE_COORD_2====

: ''params'' liefert als einzelnen boolschen Wert zurück ob 2D-Evaluation 2D-Texturkoordinaten generiert. Siehe [[glMap2]].

====GL_MAP2_TEXTURE_COORD_3====

: ''params'' liefert als einzelnen boolschen Wert zurück ob 2D-Evaluation 3D-Texturkoordinaten generiert. Siehe [[glMap2]].

====GL_MAP2_TEXTURE_COORD_4====

: ''params'' liefert als einzelnen boolschen Wert zurück ob 2D-Evaluation 4D-Texturkoordinaten generiert. Siehe [[glMap2]].

====GL_MAP2_VERTEX_3====

: ''params'' liefert als einzelnen boolschen Wert zurück ob 2D-Evaluation 3D-Vertexkoordinaten generiert. Siehe [[glMap2]].

====GL_MAP2_VERTEX_4====

: ''params'' liefert als einzelnen boolschen Wert zurück ob 2D-Evaluation 4D-Vertexkoordinaten generiert. Siehe [[glMap2]].

====GL_MAP_COLOR====

: ''params'' liefert als einzelnen boolschen Wert zurück, ob Farbwerte und Farbindizes während des Pixeltransfers durch Taballenzugriffe ersetzt werden. Siehe [[glPixelTransfer]].

====GL_MAP_STENCIL====

: ''params'' liefert als einzelnen boolschen Wert zurück, ob Stencilindizes während des Pixeltransfers durch Taballenzugriffe ersetzt werden. Siehe [[glPixelTransfer]].

====GL_MATRIX_MODE====

: ''params'' liefert als symbolische Konsante, welcher Matrizenstapel als aktuelles Ziel für alle Matrixoperationen gesetzt ist. Siehe [[glMatrixMode]].

====GL_MAX_3D_TEXTURE_SIZE====

: ''params'' liefert als einzelnen Wert die maximal mögliche Dimension (Breite=Höhe=Tiefe) einer 3D-Textur. Siehe [[glTexImage3D]].

====GL_MAX_ATTRIB_STACK_DEPTH====

: ''params'' liefert die maximale Tiefe des Attributstapels zurück. Siehe [[glPushAttrib]].

====GL_MAX_CLIP_PLANES====

: ''params'' liefert die maximale Zahl der selbst-definierbaren Schnittflächen zurück. Siehe [[glClipPlane]].

====GL_MAX_ELEMENTS_INDICES====

: ''params'' liefert als einzelnen Wert die empfohlene maximale Anzahl von Indizes zurück, die von [[glDrawRangeElements]] effektiv verarbeitet werden können.

====GL_MAX_ELEMENTS_VERTICES====

: ''params'' liefert als einzelnen Wert die empfohlene maximale Anzahl von Vertices zurück, die von [[glDrawRangeElements]] effektiv verarbeitet werden können.

====GL_MAX_EVAL_ORDER====

: ''params' liefert die maximale Funktionsordnung zurück, die von 1D- und 2D-Evaluatoren unterstützt wird. Siehe [[glMap1]] und [[glMap2]].

====GL_MAX_LIGHTS====

: ''params'' liefert die Anzahl der maximal unterstützten Lichtquellen zurück. Siehe [[glLight]].

====GL_MAX_LIST_NESTING====

: ''params'' liefert die maximale Rekursionstiefe innerhalb einer Displayliste zurück. Siehe [[glCallList]].

====GL_MAX_MODELVIEW_STACK_DEPTH====

: ''params'' liefert als einzelnen Wert die Anzahl der maximal auf den Stapel legbaren Modelansichtsmatrizen zurück. Siehe [[glPushMatrix]].

====GL_MAX_NAME_STACK_DEPTH====

: ''params'' liefert als einzelnen Wert die maximale Tiefe des Tapels für Selektionsnamen zurück. Siehe [[glPushName]].

====GL_MAX_PIXEL_MAP_TABLE====

: ''params'' liefert die maximale Größe einer [[glPixelMap]] Zugriffstabelle zurück. Siehe [[glPixelMap]].

====GL_MAX_PROJECTION_STACK_DEPTH====

: ''params'' liefert als einzelnen Wert die Anzahl der maximal auf den Stapel legbaren Projektionsmatrizen zurück. Siehe [[glPushMatrix]].

====GL_MAX_TEXTURE_SIZE====

: ''params'' liefert als einzelnen Wert die maximal mögliche Dimension (Breite=Höhe) einer 1D/2D-Textur. Siehe [[glTexImage2D]] bzw. [[glTexImage1D]].

====GL_MAX_TEXTURE_STACK_DEPTH====

: ''params'' liefert als einzelnen Wert, die Anzahl der maximal auf den Stapel legbaren Texturenmatrizen, zurück. Siehe [[glPushMatrix]].

====GL_MAX_TEXTURE_UNITS====

: ''params'' liefert als einzelnen Wert, die Anzahl der unterstützen Textureinheiten, zurück. Dieser Wert muss mindestens 1 sein. Siehe [[glActiveTexture]], [[glClientActiveTexture]] und [[glMultiTexCoord]].

====GL_MAX_VIEWPORT_DIMS====

: ''params'' liefert zwei Werte zurück, die maximale Breite und maximale Höhe des Viewports. Siehe [[glViewport]].

====GL_MODELVIEW_MATRIX====

: ''params'' liefert 16 Werte zurück. Diese entsprechen den 16 Werten der Modelview-[[Matrix]] die als letztes auf den Modelview-Matrixstack gelegt wurde.

====GL_MODELVIEW_STACK_DEPTH ====

: ''params'' liefert als einzelnen Wert die Anzahl der Matrizen auf dem Matrizenstapel für die Modelansichtsmatrix zurück. Siehe [[glPushMatrix]].

===N===

====GL_NAME_STACK_DEPTH ====

: ''params'' liefert als einzelnen Wert die Zahl der Namen auf dem Namensstapel zurück.

====GL_NORMAL_ARRAY_SIZE====

:''params'' liefert als einzelnen Parameter die Anzahl der Koordinaten pro Element im Normalen-Array zurück. Siehe [[glNormalPointer]].

====GL_NORMAL_ARRAY_STRIDE====

:''params'' liefert als einzelnen Parameter den Byteversatz zwischen den aufeinander folgenden Elementen in einem Normalen-Array zurück. Siehe [[glNormalPointer]].

====GL_NORMAL_ARRAY_TYPE====

:''param'' liefert als einzelnen Wert den Datentyp für die Koordinaten in einem Normalen-Array zurück. Siehe [[glNormalPointer]].

====GL_NORMALIZE ====

: ''params'' gibt als einzelner boolscher Wert an, ob Normalen nach der Transformation in Betrachterkoordinaten automatisch auf Einheitslänge gebracht werden. Siehe [[glEnable]].

===P===

====GL_PACK_ALIGNMENT ====

: ''params'' liefert als einzelnen Wert die Byteausrichtung für das Schreiben von Pixeldaten in den Speicher zurück. Siehe [[glPixelStore]].

====GL_PACK_LSB_FIRST ====

: ''params'' gibt als einzelnen boolschen Wert zurücl, ob Ein-Bit Pixel die in den Speicher geschrieben werden zuerst in das niederwertigste Bit eines jeden vorzeichenlosen Bytes geschrieben werden. Siehe [[glPixelStore]].

====GL_PACK_ROW_LENGTH====

: ''params'' liefert als einzelnen Wert die Reihenlänge zurück, die zum Schreiben von Pixeldaten in den Speicher genutzt wird. Siehe [[glPixelStore]].

====GL_PACK_SKIP_PIXELS ====

: ''params'' gibt als einzelnen Wert die Zahl der Pixel zurück, die vor dem Schreiben des ersten Pixels in den Speicher übersprungen werden. Siehe [[glPixelStore]].

====GL_PACK_SKIP_ROWS====

: ''params'' gibt als einzelnen Wert die Zahl der Pixelreihen zurück, die vor dem Schreiben des ersten Pixels in den Speicher übersprungen werden. Siehe [[glPixelStore]].

====GL_PACK_SWAP_BYTES====

: ''params'' gibt als boolschen Wert an, ob Bytes von Zwei-Byte und Vier-Byte Pixelindizes und Komponenten vertauscht werden, bevor sie in den Speicher geschrieben werden. Siehe [[glPixelStore]].

====GL_PERSPECTIVE_CORRECTION_HINT ====

: ''params'' gibt als symbolische Konstante den Hinweismodus für perspektivische Korrektion zurück. Siehe [[glHint]].

====GL_PIXEL_MAP_A_TO_A_SIZE ====

: ''params'' liefert als einzelnen Wert die Größe der Alpha-nach-Alpha Pixelübersetzungstabelle zurück. Siehe [[glPixelMap]].

====GL_PIXEL_MAP_B_TO_B_SIZE ====

: ''params'' liefert als einzelnen Wert die Größe der Blau-nach-Blau Pixelübersetzungstabelle zurück. Siehe [[glPixelMap]].

====GL_PIXEL_MAP_G_TO_G_SIZE====

: ''params'' liefert als einzelnen Wert die Größe der Grün-nach-Grün Pixelübersetzungstabelle zurück. Siehe [[glPixelMap]].

====GL_PIXEL_MAP_I_TO_A_SIZE ====

: ''params'' liefert als einzelnen Wert die Größe der Index-nach-Alpha Pixelübersetzungstabelle zurück. Siehe [[glPixelMap]].

====GL_PIXEL_MAP_I_TO_B_SIZE====

: ''params'' liefert als einzelnen Wert die Größe der Index-nach-Blau Pixelübersetzungstabelle zurück. Siehe [[glPixelMap]].

====GL_PIXEL_MAP_I_TO_G_SIZE ====

: ''params'' liefert als einzelnen Wert die Größe der Index-nach-Grün Pixelübersetzungstabelle zurück. Siehe [[glPixelMap]].

====GL_PIXEL_MAP_I_TO_I_SIZE ====

: ''params'' liefert als einzelnen Wert die Größe der Index-nach-Index Pixelübersetzungstabelle zurück. Siehe [[glPixelMap]].

====GL_PIXEL_MAP_I_TO_R_SIZE ====

: ''params'' liefert als einzelnen Wert die Größe der Index-nach-Rot Pixelübersetzungstabelle zurück. Siehe [[glPixelMap]].

====GL_PIXEL_MAP_R_TO_R_SIZE ====

: ''params'' liefert als einzelnen Wert die Größe der Rot-nach-Rot Pixelübersetzungstabelle zurück. Siehe [[glPixelMap]].

====GL_PIXEL_MAP_S_TO_S_SIZE ====

: ''params'' liefert als einzelnen Wert die Größe der Stencil-nach-Stencil Pixelübersetzungstabelle zurück. Siehe [[glPixelMap]].

====GL_POINT_DISTANCE_ATTENUATION====

: ''params'' liefert drei Werte zurück, die für die Berechnung der Abstands-Attenuation-Funktion benötigt werden. Der erste Wert liefert den konstanten, der zweite Wert den linearen und der dritte Wert den quadratischen Abstands-Attenuation-Funktionskoeffizienten. Siehe [[glPointParameter]], [[glPointSize]].

====GL_POINT_FADE_THRESHOLD_SIZE====

: ''params'' liefert als einzelnen Wert einen Schwellwert, ab der der Abblendfaktor für einen Punkt berechnet wird. Siehe [[glPointParameter]], [[glPointSize]].

====GL_POINT_SIZE====

: ''params'' gibt als einzelnen Wert die mit [[glPointSize]] angegebene aktuelle Punktgröße zurück.

====GL_POINT_SIZE_GRANULARITY====

: ''params'' liefert als einzelnen Wert den möglichen Größenunterschied zwischen zwei Punkt-Größenangaben zurück. Siehe [[glPointSize]].

====GL_POINT_SIZE_MAX====

: ''params'' liefert als einzelnen Wert die absolute Obergrenze für die abgeleitete Punktgrösse zurück. Siehe [[glPointParameter]], [[glPointSize]].

====GL_POINT_SIZE_MIN====

: ''params'' liefert als einzelnen Wert die absolute Untergrenze für die abgeleitete Punktgrösse zurück. Siehe [[glPointParameter]], [[glPointSize]].

====GL_POINT_SIZE_RANGE====

: ''params'' liefert zwei Werte zurück, die kleinst- und größtmögliche Größenangabe für Punkte. Siehe [[glPointSize]].

====GL_POINT_SMOOTH====

: ''params'' gibt als einzelnen boolschen Wert an, ob Kantenglättung für Punkteaktiv ist. Siehe [[glPointSize]].

====GL_POINT_SMOOTH_HINT====

: ''params'' liefert als symbolische Konstante den Hinweismodus für die Kantenglättung von Punkten zurück. Siehe [[glHint]].

====GL_POINT_SPRITE_COORD_ORIGIN====

: ''params'' liefert als einzelnen Wert eine symbolische Konstante, die angibt, von wo aus die Texturkoordinate t anfängt zu zählen. Mögliche Wertrückgaben sind '''GL_LOWER_LEFT''' und '''GL_UPPER_LEFT'''. Siehe [[glPointParameter]], [[glPointSize]].

====GL_POLYGON_MODE====

: ''params'' liefert als zwei symbolische Konstanten zurück, ob nach vorne- oder nach hinten zeigende Polygone entweder als Punkte, Linien oder Flächen rasterisiert werden. Siehe [[glPolygonMode]].

====GL_POLYGON_SMOOTH====

: ''params'' gibt als einzelnen boolschen Wert an, ob Kantenglättung für Polygone aktiv ist. Siehe [[glPolygonMode]].

====GL_POLYGON_SMOOTH_HINT====

: ''params'' liefert als symbolische Konstante den Hinweismodus für die Kantenglättung von Polygonen zurück. Siehe [[glHint]].

====GL_POLYGON_STIPPLE====

: ''params'' gibt als einzelnen boolschen Wert an ob Musterung für Polygone aktiviert ist. Siehe [[glPolygonStipple]].

====GL_PROJECTION_MATRIX====

: ''params'' liefert 16 Werte zurück. Diese entsprechen den 16 Werten der Projektions-[[Matrix]] die als letztes auf den Projektions-Matrixstack gelegt wurde..

====GL_PROJECTION_STACK_DEPTH ====

: ''params'' liefert als einzelnen Wert die Anzahl der auf dem Projektionsmatrizenstapel liegenden Matrizen zurück. Siehe [[glPushMatrix]].

===R===

====GL_READ_BUFFER====

: ''params'' liefert als einzelnen boolschen Wert eine symbolische Konstante zurück, die angibt welcher Farbpuffer als Lesepuffer gesetzt ist. Siehe [[glReadPixels]] und [[glAccum]].

====GL_RED_BIAS====

: ''params'' gibt als einzelnen Wert den Rotverschiebungsfaktor an, der beim Pixeltransfer genutzt wird.

====GL_RED_BITS====

: ''params'' gibt als (Gannzahl)Wert die Anzahl der Bitflächen (Bittiefe) für den Rotanteil eines Farbpuffers zurück.

====GL_RED_SCALE====

: ''params'' liefert als einzelnen Wert den Skalierungsfaktor für den roten Farbanteil zurück, der beim Pixeltransfer angewandt wird. Siehe [[glPixelTransfer]].

====GL_RENDER_MODE====

: ''params'' liefert einen symbolische Konstante zurück, die angibt in welchem Rendermodus sich die GL befindet (Rendern, Selektion oder Feedbackmodus). Siehe [[glRenderMode]].

====GL_RESCALE_NORMAL====

: ''params'' gibt als einzelnen boolschen Wert an ob die Reskalierung von [[Normalen]] aktiv ist. Siehe [[glEnable]].

====GL_RGBA_MODE====

: ''params'' gibt als einzelnen boolschen Wert zurück, ob sich die GL im RGBA-Modus (='''true''') oder im indizierten Farbmodus (='''false''') befindet. Siehe [[glColor]].

===S===

====GL_SAMPLE_COVERAGE_INVERT====
: ''params'' gibt einen einzelnen booleanschen Wert zurück, der angibt, ob der temporäre Überdeckungswert beim [[Multisampling]] invertiert werden soll. Siehe [[glSampleCoverage]].

====GL_SAMPLE_COVERAGE_VALUE====
: ''params'' gibt eine einzelne Fließkomma-Zahl zurück, die den temporären Überdeckungswert beim [[Multisampling]] angibt. Siehe [[glSampleCoverage]].

====GL_SCISSOR_BOX====

: ''params'' gibt vier Ganzzahlwerte zurück. Die X- und Y-Fensterkoordinaten der Scissorbox, gefolgt von ihrer Breite und Höhe. Siehe [[glScissor]].

====GL_SCISSOR_TEST====

: ''params'' gibt einen einzelnen booleanschen Wert zurück, der angibt ob Scissoring aktiviert ist. Siehe [[glScissor]].

====GL_SECONDARY_COLOR_ARRAY_SIZE====

:''params'' liefert als einzelnen Parameter die Anzahl der Komponenten pro Element im Zweitfarben-Array zurück. Siehe [[glSecondaryColorPointer]].

====GL_SECONDARY_COLOR_ARRAY_STRIDE====

:''params'' liefert als einzelnen Parameter den Byteversatz zwischen den aufeinander folgenden Elementen in einem Zweitfarben-Array zurück. Siehe [[glSecondaryColorPointer]].

====GL_SECONDARY_COLOR_ARRAY_TYPE====

:''param'' liefert als einzelnen Wert den Datentyp für die Komponenten in einem Zweitfarben-Array zurück. Siehe [[glSecondaryColorPointer]].

====GL_SHADE_MODEL====

: ''params'' gibt einen einzelnen Ganzzahlwert zurück, eine symbolische Konstante die angibt ob der Schattierungsmodus flach oder weich ist. Siehe [[glShadeModel]].

====GL_STENCIL_BITS====

: ''params'' liefert einen Ganzzahlwert zurück, der die Zahl der Bitflächen des Stencilpuffers enthält.

====GL_STENCIL_CLEAR_VALUE====

: ''params'' gibt einen Wert zurück, den Index mit dem die Bitflächen des Stencilpuffers gelöscht werden. Siehe [[glClearStencil]].

====GL_STENCIL_FAIL====

: ''params'' liefert als einzelnen Wert eine symbolische Konstante zurück, die angibt was passiert wenn der Stenciltest fehlschlägt. Siehe [[glStencilOp]].

====GL_STENCIL_FUNC====

: ''params'' liefert als einzelnen Wert eine symbolische Kosntante zurück, die angibt welche Funktion zum Vergleich der Referenz-Stencilwerte mit dem Inhalt des Stencilpuffers genutzt wird. Siehe [[glStencilFunc]].

====GL_STENCIL_PASS_DEPTH_FAIL====

: ''params'' liefert als einzelnen Wert eine symbolische Konstante zurück, die angibt was passiert wenn der Stenciltest passiert, der Tiefentest jedoch fehlschlägt. Siehe [[glStencilOp]].

====GL_STENCIL_PASS_DEPTH_PASS====

: ''params'' liefert als einzelnen Wert eine symbolische Konstante zurück, die angibt was passiert wenn der Stenciltest und der Tiefentest passieren. Siehe [[glStencilOp]].

====GL_STENCIL_REF====

: ''params'' liefert als einzelnen Wert den Referenzwert zurück, der bei Stencilvergleichen genutzt wird. Siehe [[glStencilFunc]].

====GL_STENCIL_TEST====

: ''params'' gibt einen einzelnen booleanschen Wert zurück, der angibt ob der Stenciltest für Fragmente aktiviert ist. Siehe [[glStencilFunc]] und [[glStencilOp]].

====GL_STENCIL_VALUE_MASK====

: ''params'' liefert als einzelnen Wert die Maske zurück, die genutzt wird um sowohl den Stencil-Vergleichswert als auch den Stencilpufferwert vor dem Vergleich zu maskieren. Siehe [[glStencilFunc]].

====GL_STENCIL_WRITEMASK====

: ''params'' liefert als einzelnen Wert die Maske zurück, die das Schreiben in den Stencilpuffer kontrolliert. Siehe [[glStencilMask]].

====GL_STEREO ====

: ''params'' gibt einen einzelnen Booleanwert zurück der an gibt, ob Stereobuffer (links und rechts) unterstützt werden.

====GL_SUBPIXEL_BITS====

: ''params'' liefert als einzelnen Wert eine Schätzung der Zahl der Bits an Unterpixelauflösung zurück, der genutzt wird um Geometrie in Fensterkoordinaten zu rasterisieren.

===T===

====GL_TEXTURE_1D====

:''params'' liefert als booleanschen Wert zurück, ob ein-dimensionales Texturemapping aktiviert ist. Siehe [[glTexImage1D]].

====GL_TEXTURE_2D====

:''params'' liefert als booleanschen Wert zurück, ob zwei-dimensionales Texturemapping aktiviert ist. Siehe [[glTexImage2D]].

====GL_TEXTURE_3D====

:''params'' liefert als booleanschen Wert zurück, ob drei-dimensionales Texturemapping aktiviert ist. Siehe [[glTexImage3D]].

====GL_TEXTURE_BINDING_1D====

:''params'' liefert in einem einzigen Wert den Namen der aktuell an das Ziel '''GL_TEXTURE_1D''' gebundenen Textur. Siehe [[glBindTexture]].

====GL_TEXTURE_BINDING_2D====

:''params'' liefert in einem einzigen Wert den Namen der aktuell an das Ziel '''GL_TEXTURE_2D''' gebundenen Textur. Siehe [[glBindTexture]].

====GL_TEXTURE_BINDING_3D====

:''params'' liefert in einem einzigen Wert den Namen der aktuell an das Ziel '''GL_TEXTURE_3D''' gebundenen Textur. Siehe [[glBindTexture]].

====GL_TEXTURE_COORD_ARRAY====

:''params'' liefert einen booleanschen Wert zurück, der angibt ob das Texturkoordinaten-Array aktiv ist. Siehe [[glTexCoordPointer]].

====GL_TEXTURE_COORD_ARRAY_SIZE====

:''params'' liefert als einzelnen Paramter die Anzahl der Koordinaten pro Element im Texturkoordinaten-Array zurück. Siehe [[glTexCoordPointer]].

====GL_TEXTURE_COORD_ARRAY_STRIDE====

:''params'' liefert als einzelnen Parameter den Byteversatz zwischen den aufeinander folgenden Elementen in einem Texturkoordinaten-Array zurück. Siehe [[glTexCoordPointer]].

====GL_TEXTURE_COORD_ARRAY_TYPE====

:''param'' liefert als einzelnen Wert den Datentyp für die Koordinaten in einem Texturkoordinaten-Array zurück. Siehe [[glTexCoordPointer]].

====GL_TEXTURE_ENV_COLOR====

:''params'' liefert vier Werte zurück : Den roten, grünen, blauen und Alpha-Anteil der Texturenumgebungsfarbe. Integerwerte (falls angefordert) werden linear im Bezug zur Fließkommarepräsentation umgerechnet, so dass 1.0 dien höchstmöglichen positiven Integerwert zurückgibt. Siehe [[glTexEnv]].

====GL_TEXTURE_ENV_MODE====

:''params'' liefert als einzelnen Wert eine symbolische Konstante zurück, die angbit welche Texturenumgebungs-Funktion zurzeit aktiv ist. Siehe [[glTexEnv]].

====GL_TEXTURE_GEN_S====

:''params'' liefert als booleanschen Wert zurück, ob die automatische Generierung der S-Texturkoordiante aktiv ist. Siehe [[glTexGen]].

====GL_TEXTURE_GEN_T====

:''params'' liefert als booleanschen Wert zurück, ob die automatische Generierung der T-Texturkoordiante aktiv ist. Siehe [[glTexGen]].

====GL_TEXTURE_GEN_R====

:''params'' liefert als booleanschen Wert zurück, ob die automatische Generierung der R-Texturkoordiante aktiv ist. Siehe [[glTexGen]].

====GL_TEXTURE_GEN_Q====

:''params'' liefert als booleanschen Wert zurück, ob die automatische Generierung der Q-Texturkoordiante aktiv ist. Siehe [[glTexGen]].

====GL_TEXTURE_MATRIX====

: ''params'' liefert 16 Werte zurück. Diese entsprechen den 16 Werten der Texture-[[Matrix]] die als letztes auf den Texture-Matrixstack gelegt wurde.

====GL_TEXTURE_STACK_DEPTH====

: ''params'' liefert einen Wert, die Anzahl der Matrizen auf dem Texturmatrixstack, zurück.

===U===

====GL_UNPACK_ALIGNMENT====

:''params'' liefert als einzelnen Wert die Byteausrichtung zurück, die beim Lesen von Pixeln aus dem Speicher genutzt wird. Siehe [[glPixelStore]].

====GL_UNPACK_IMAGE_HEIGHT_EXT====
:''params'' liefert als einzelnen Wert die Höhe und Breite des Bildes zurück das genutzt wird um (3D-)Pixel aus dem Speicher zu lesen. Siehe [[glPixelStore]].

====GL_UNPACK_LSB_FIRST====

:''params'' liefert als einzelnen booleanschen Wert zurück, ob Ein-Bit-Pixel die aus dem Speicher ausgelesen werden zuerst aus dem niederwertigsten Bit jedes vorzeichenlosen Bytes gelesen werden. Siehe [[glPixelStore]].

====GL_UNPACK_ROW_LENGTH====

:''params'' liefert als einzelnen Wert die Reihenlänge zurück, die beim Auslesen der Pixel aus dem Speicher verwendet wird. Siehe [[glPixelStore]].

====GL_UNPACK_SKIP_IMAGES_EXT====

:''params'' liefert als einzelnen Wert die Anzahl der Bilder die übersprungen werden, bevor der erste (3D-)Pixel aus dem Speicher gelesen wird. Siehe [[glPixelStore]].

====GL_UNPACK_SKIP_PIXELS====

:''params'' liefert als einzelnen Wert die Anzahl der Pixel die übersprungen werden, bevor der erste Pixel aus dem Speicher gelesen wird. Siehe [[glPixelStore]].

====GL_UNPACK_SKIP_ROWS====

:''params'' liefert als einzelnen Wert die Anzahl der Pixelreihen zurück, die beim Lesen aus dem Speicher übersprungen werden. Siehe [[glPixelStore]].

====GL_UNPACK_SWAP_BYTES====

:''params'' gibt einen einzelnen booleanschen Wert zurück, der angibt ob die Bytes von Zwei-Byte und Vier-Byte Pixelindizes und -komponenten nach dem Auslesen aus dem Speicher vertauscht werden. Siehe [[glPixelStore]].

===V===

====GL_VERTEX_ARRAY_SIZE====

:''params'' liefert als einzelnen Parameter die Anzahl der Koordinaten pro Element im Vertex-Array zurück. Siehe [[glVertexPointer]].

====GL_VERTEX_ARRAY_STRIDE====

:''params'' liefert als einzelnen Parameter den Byteversatz zwischen den aufeinander folgenden Elementen in einem Vertex-Array zurück. Siehe [[glVertexPointer]].

====GL_VERTEX_ARRAY_TYPE====

:''param'' liefert als einzelnen Wert den Datentyp für die Koordinaten in einem Vertex-Array zurück. Siehe [[glVertexPointer]].

====GL_VIEWPORT====

:''params'' liefert vier Parameter zurück. Die X- und Y-Koordinaten des Viewports, gefolgt von dessen Breite und Höhe. Siehe [[glViewport]].

===Z===

====GL_ZOOM_X====

:''params'' gibt als einzelnen Wert den Vergrößerungsfaktor für Pixel auf der X-Achse zurück. Siehe [[glPixelZoom]].

====GL_ZOOM_Y====

:''params'' gibt als einzelnen Wert den Vergrößerungsfaktor für Pixel auf der Y-Achse zurück. Siehe [[glPixelZoom]].

== Fehlermeldungen ==

'''GL_INVALID_ENUM''' wird generiert, wenn ''pname'' ein ungültiger Wert übergeben wird. 
'''GL_INVALID_OPERATION''' wird generiert, wenn '''glGet''' innerhalb eines [[glBegin]]-[[glEnd]] Blocks aufgerufen wird.

==Siehe Auch==
[[glGetClipPlane]], [[glGetError]], [[glGetLight]], [[glGetMap]], [[glGetMaterial]], [[glGetPixelMap]], [[glGetPolygonStipple]], [[glGetString]], [[glGetTexEnv]], [[glGetTexGen]], [[glGetTexImage]], [[glGetTexLevelParameter]], [[glGetTexParameter]], [[glIsEnabled]]

==Links==
[http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/glfunc02_5ub8.asp Spezifikation von glGet in der MSDN]

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

Tutorial 2D

2008-04-03T08:56:57Z

Damadmax: Verweise glScale auf glScalef

Tutorial StencilSpiegel

2008-04-03T08:54:00Z

Damadmax: Verweis glScalef auf glScale

=Realistische Spiegelungen - Spiel, Spaß und Spannung mit dem Stencil-Puffer=

==Vorwort==
Ave!

Herzlich willkommen zu meinem ersten Tutorial für DGL. Einige Leser dürften schon die von mir auf meiner Seite veröffentlichen Tutorials kennen, von nun an werde ich jedoch verstärkt Tutorials für die DGL veröffentlichen.

In dieser Lektion geht es um die realistische Darstellung von Spiegelungen mit Hilfe des [[Schablonenpuffer|Stencilpuffers]]. 
Diese Technik findet langsam aber sicher Verbreitung in der Spieleindustrie. Das hat zum einen den Grund, das spiegelnde Flächen in der realen Welt sehr häufig vorkommen, und ihre Nachahmung einer 3D-Welt noch ein Stück mehr an Realitätsnähe verleiht. Der weitere Grund, warum realistische Spiegelungen erst seit kurzem verwendet werden, ist die Tatsache das die Szene mindestens zwei mal gerendert werden muß, und das die Grafikkarte einen [[Schablonenpuffer|Stencilpuffer]] mitbringen muß. Moderne 3D-Beschleuniger besitzen ihn natürlich, aber die damals so weit verbreitete Vodoo-Serie besaß diesen nicht.

==Der Stencil-Puffer==

Wie schon erwähnt ist der [[Schablonenpuffer|Stencilpuffer]] ein wichtigste Mittel um realistische Spiegelungen (und noch viele andere interessante Dinge) zu realisieren. Wie das Wort Stencil (=Schablone) schon andeutet, kann man in diesem Puffer eine Schablone ablegen, die später bestimmt welcher Bereich des Bildschirms überzeichnet, und welcher Bereich unberührt bleibt. 
Die Tiefe des [[Schablonenpuffer|Stencilpuffers]] ist je nach Hardware unterschiedlich, inzwischen kann man aber auf jeder aktuelleren Karte von mindestens 8-Bit für diesen Puffer (oft werden dann die 24-Bit für den Tiefenpuffer mit diesen kombiniert um ein DWORD zu erhalten) ausgehen.

Ein praktisches Anwendungsbeispiel für die Nutzung dieses Puffers zur Begrenzung der zu überzeichnenden Fläche wäre z.B. die Cockpitansicht einer Flugsimulation. Zuerst wird der [[Schablonenpuffer|Stencilpuffer]] aktiviert, und dann wird das Cockpit in diesen Puffer "hineingezeichnet" und als Ausschlussmaske benutzt. Überall dort wo das Cockpit im [[Schablonenpuffer|Stencilpuffer]] einen Pixel hinterlassen hat wird später im [[Farbpuffer|Farbpuffer]] nicht gezeichnet.Dadurch muss das Cockpit also nur einmal gezeichnet werden. Die folgende Bildreihe verdeutlicht dies :

<div align="center">
{|{{Prettytable}}
|width="25%" |[[Bild:Tutorial_Stencil_cockpit01.jpg|center]]
|width="25%" |[[Bild:Tutorial_Stencil_cockpit02.jpg|center]]
|width="25%" |[[Bild:Tutorial_Stencil_cockpit03.jpg|center]]
|width="25%" |[[Bild:Tutorial_Stencil_cockpit04.jpg|center]]
|-
|align="center" | Cockpit-Textur (oder 3D-Modell) (wird in den Stencilpuffer gezeichnet)
|align="center" | Inhalt des Stencil-Puffers (Schwarz : Stencil-Wert = 0) (Weiß : Stencil-Wert = 1)
|align="center" | Auf dem Bildschirm sichtbarer Teil der Szene
|align="center" | Endergebnis
|}
</div>

Jetzt fragt ihr euch bestimmt, was dieses Cokpit-Beispiel mit unserer Spiegelung zu tun hat?
Ganz einfach : Zum einen erleichtert es das Verständnis der Funktionsweise des [[Schablonenpuffer|Stencilpuffers]], was unbedingt notwendig ist, und zum anderen funktioniert die Sache mit dem Spiegel genau umgekehrt. 
Während der [[Schablonenpuffer|Stencilpuffer]] im Cockpit-Beispiel dazu genutzt wird, den Teil an dem sich das Cockpit befindet vor dem Überschreiben durch andere Farbwerte zu bewahren, wird der Puffer bei einer Spiegelung dazu genutzt, den Bereich ausserhalb des Spiegels vorm Überschreiben zu schützen. So wird also nur der Teil der Szene gezeichnet, die sich auch "im" Spiegel befindet. 
Wozu der [[Schablonenpuffer|Stencilpuffer]] also gut ist, lässt sich anhand der folgenden zwei Screenshots wohl am besten verdeutlichen. Während der Spiegel im linken Bild korrekt ist, und das Spiegelbild ausserhalb der Spieglfläche aufgrund des Stenciltests nicht gezeichnet wird, ist das Spiegelbild rechts falsch. Hier wurde der Stenciltest deaktiviert :

<center> [[Bild:Tutorial_Stencil_Trooper04.jpg]] [[Bild:Tutorial_Stencil_Trooper03.jpg]] </center>

==Clipping Plane==
Ein weiterer, für unseren Zweck notwendiger Begriff sind die [[Clipping Plane]]s (zu Deutsch : Schnittflächen). Das ist aber nichts mathematisch unmögliches, sondern eine ganz einfache Fläche, an der die Geometrie "abgeschnitten" wird. D.h., dass alles was auf der per Vorzeichen definierten Seite dieser Schnittfläche liegt einfach nicht gezeichnet wird. 
OpenGL bringt von Haus aus schonmal sechs solcher Clipping-Planes mit, die zusammen das Frustum ergeben, also der Quader, an dem die Geometrie aufgrund ihrer Sichtbarkeit "abgeschnitten" wird.

Darüberhinaus kann man jedoch selbst noch zusätzliche Schnittflächen definieren. Laut OpenGL-Vorgaben muß jeder OpenGL-Treiber mindestens sechs zusätzliche Schnittflächen anbieten können. Für unseren Spiegel reicht jedoch eine.

Eine Clippingplane wird mittels der Funktion {{INLINE_CODE|[[glClipPlane]](plane: TGLEnum; equation: PGLdouble)}}, wobei die Fläche mittles eines {{INLINE_CODE|array[0..3] of Double}} über ihre Gleichung ''Ax+By+Cz+D = 0'' definiert wird. Aktiviert bzw. deaktiviert wird eine Schnittfläche mittels der Konstante '''GL_CLIP_PLANE'''i, wobei i für die Nummer der Schnittfläche steht und zwischen 0 und 5 liegt.

Das hört sich jetzt erstmal leicht trocken an, und dürfte ohne praktisches Beispiel auch nicht hängen bleiben. Deshalb hier zwei Screenshots aus dem Beispielprogramm zu diesem Tutorial, die verdeutlichen wozu die Schnittfläche benötigt wird. Der Spiegel liegt hier im Koordinatensystem am Ursprung (x:0,y:0,z:0) und "liegt" auf der Y-Achse. 
Definiert wird dieser Spiegel deshalb als {{INLINE_CODE|array[0..3] of Double = (0, 0, -1, 0)}}. Das Minus vor der Eins gibt also quasi an, auf welcher Seite der Spiegelfläche geclippt werden soll. Würde der Spielerraum also auf der anderen Seite liegen, wäre das Vorzeichen positiv.

<center>
{|border=0
|[[Bild:Tutorial_Stencil_Trooper01.jpg|framed|Ohne Clipping]]
|[[Bild:Tutorial_Stencil_Trooper02.jpg|framed|Mit Clipping]]
|-
|}
</center>

==Programmiertechnische Umsetzung==

Nachdem wir nun mit der Begriffserklärung abgeschlossen haben und jedem klar sein sollte, was ein [[Schablonenpuffer|Stencilpuffers]] macht und wozu eine [[Clipping Plane]] gut ist, widmen wir uns nun der Implementation eines Spiegels in unser Programm. Der Quelltext zu diesem Thema ist zwar relativ kurz, bietet aber dennoch einiges an Erklärungsspielraum. 
''Deshalb : Nicht einfach nur abtippen, sondern auch sorgfältig meine mehr oder weniger ausführlichen Erklärungen mitlesen.''

Die Renderprozedur sowohl für die normale Szene als auch für den Spiegelraum befindet sich im Beispielprogramm in der Prozedur ''DrawScene_Stencil''. Im folgenden Kapitel werden alle relevante Teile dieser Prozedur besprochen, unwichtige Grundlagen lasse ich jedoch weg. Jeder der sich mit Spiegelungen beschäftigen will, sollte sich mit den OpenGL-Grundlagen auskennen.

===Definition der Schnittfläche===

Zu allererst definieren wir die Schnittfläche an der das Spiegelbild abgeschnitten wird. Würden wir diesen Teil weglassen, dann würden spätestens beim Durchschreiten eines Spiegels (auch wenn das in einem Ego-Shooter nicht vorkommen sollte) hässlich falsche Spiegelbilder entstehen...und das wollen wir ja nicht, schliesslich soll unser Spiegel ja die reale Welt nachstellen. Wie die Schnittfläche definiert wird, haben wir ja oben bereits besprochen. Wichtig wäre hier vielleicht noch, dass als Datentyp unbedingt Double verwendet werden muß. Andere Datentypen (z.B. Single) führen zu unvorhersehbaren Effekten.

const
ClipPlane : array[0..3] of Double = (0, 0, -1, 0);

===Den Stencil-Puffer löschen===
Wie bekannt müssen (oder sollten) die verwendeten OpenGL-Puffer vor jedem neuen Zeichendurchgang gelöscht werden. Dies geschieht ja bekannterweise mit der Funktion [[glClear]]() und als Parameter oderverknüpft die zu löschenden Puffer. Neben den Bits für den [[Farbpuffer]] ('''GL_COLOR_BUFFER_BIT''') und dem [[Tiefenpuffer]] ('''GL_DEPTH_BUFFER_BIT''') kommt nun ein neues Puffer-Bit dazu, nämlich '''GL_STENCIL_BUFFER_BIT''', um den [[Schablonenpuffer|Stencilpuffer]] zu "löschen".

Löschen habe ich deshalb in Anführungszeichen gesetzt, weil der [[Schablonenpuffer|Stencilpuffer]] nicht einfach wie z.B. der [[Farbpuffer]] geleert wird, sondern durch {{INLINE_CODE|glClear(GL_STENCIL_BUFFER_BIT)}} mit einem vorher definierten Wert gefüllt wird. Dieser Wert wird (am besten bei der OpenGL-Initialisierung) mittels {{INLINE_CODE|[[glClearStencil]](s:Integer)}} festgelegt. In unserem Falle übergeben wir als hier Parameter den Wert 0.

// Löschen des Stencil-Puffers zum Beginn der Szene
glClear(GL_DEPTH_BUFFER_BIT or GL_COLOR_BUFFER_BIT or GL_STENCIL_BUFFER_BIT);

===Den Stencil-Puffer vorbereiten und die Maske erstellen===

Kommen wir nun also zum schwierigsten Teil dieses Tutorials. Die folgenden Zeilen aktiveren den [[Schablonenpuffer|Stencilpuffer]] und erstellen die Maske unseres Spiegels in diesem Puffer. Leider lassen sich die jetzt kommenden Befehle und Funktionen nicht ganz so einfach beschreiben.

glColorMask(False, False, False, False);

Mit der Funktion {{INLINE_CODE|[[glColorMask]](R,G,B,A : ByteBool)}} teilen wir OpenGL mit, welche Farbkomponenten auf den Bildschirm gezeichnet werden. In unserem Falle deaktivieren wir alle Farbkomponenten, es wird also nichts auf den Bildschirm gezeichnet. 
Dies ist insofern nötig, da wir jetzt erstmal unsere Maske in den [[Schablonenpuffer|Stencilpuffer]] zeichnen wollen, und dies kein Puffer ist in den man direkt hineinschreiben kann (wie das beim Farbpuffer der Fall ist). Wir müssen also den Weg über den Farbpuffer gehen.

glEnable(GL_STENCIL_TEST);

Zu diesem Befehl muss ich wohl kaum Worte verlieren. Kurz und schmerzlos : Er aktiviert den Stencil-Test und damit verbunden auch den [[Schablonenpuffer|Stencilpuffer]].

[[glStencilFunc]](GL_ALWAYS, 1, 1);

Mit diesem Befehl teilen wir OpenGL mit, welcher Test auf jeden gezeichneten Pixel angewendet werden soll. Der erste Parameter '''GL_ALWAYS''' gibt an, dass der Test immer erfolgreich ist. Der zweite Parameter gibt den Referenzwert für diesen Test an (den wir gleich noch brauchen werden). Wenn der Test z.B. '''GL_LESS''' wäre, dann würde das Pixelfragment den Test bestehen, wenn es kleiner als der im Referenzparameter angegebene Wert wäre. 
Der letzte Parameter gibt die Maske an, mit der unsere Referenzparameter beim Gelingen des Tests verunded wird. Wenn der Test also gelingt, wird eine 1 in den [[Schablonenpuffer|Stencilpuffer]] geschrieben (Test gelungen->Stencil-Wert = Refernzwert UND Maskenwert -> 1 UND 1 = 1).

glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);

Nach obigem OpenGl-Vorschlaghammer kommt jetzt wieder etwas leichter verdauliche Kost. Mit der Funktion {{INLINE_CODE|[[glStencilOp]](fail, zfail, zpass: TGLEnum)}} teilen wir OpenGL mit, wie der Stencilwert verändert wird, wenn ein Fragment den Test besteht oder nicht besteht. Dabei unterscheidet OpenGL anhand der drei übergebenen Parameter drei verschiedene Szenarien :

*Fail
: Diese Funktion wird angewendet, wenn das Fragment den '''Stencil-Test nicht besteht'''
*zFail
: Wird angewendet, wenn das Fragment den '''Tiefentest nicht besteht'''
*zPass
: Wird angewendet, wenn das Fragment den '''Test besteht''' (Wichtigste Funktion!)

Die ersten zwei Parameter sind in unserem Falle relativ uninteressant, weshalb wir OpenGL über '''GL_KEEP''' mitteilen dass der [[Schablonenpuffer|Stencilpuffer]] in diesen beiden Fällen nicht verändert wird.
Der dritte Parameter ist jedoch sehr wichtig : Er gibt an, was OpenGL mit dem Stencil-Puffer macht, wenn das Fragment den Test besteht. In unserem Fall soll der Stencil-Pufferwert über '''GL_REPLACE''' mit dem veränderten Masken- und Referenzwert (=1) ersetzt werden.

==Wer die Hoffnung jetzt noch nicht verloren hat, der hats fast geschafft. Das Schwerste liegt bereits hinter uns!==

glDisable(GL_DEPTH_TEST);
glDisable(GL_TEXTURE_2D);
DrawMirror;

Diese drei Zeilen sind ja schon fast selbsterklärend, aber aufgrund dessen was oben auf das Gehirn zukam auch eher zur Entspannung gedacht. Bevor wir mit ''DrawMirror'' unsere Spiegelfäche in den Stencil-Puffer zeichnen, deaktivieren wir den Tiefentest und das Texturemapping.
Nun haben wir eine unsichtbare Maske unseres Spiegels im [[Schablonenpuffer|Stencilpuffer]]. Überall dort, wo unsere Spiegelfläche in den Stencilpuffer gezeichnet wurde, steht eine 1 (=Referenzwert und Maksenwert, da der Test bestanden wurde).
Solange der Stenciltest jetzt also aktiv bleibt, wird nur dort gezeichnet wo unsere Spiegelfläche im Stencilpuffer eine 1 hinterlies.

glEnable(GL_TEXTURE_2D);
glEnable(GL_DEPTH_TEST);
glColorMask(True, True, True, True);

Da wir nun beginnen die Szene hinter dem Spiegel (also quasi das Spiegelbild) zu zeichnen, aktivieren wir sowohl das Texturemapping als auch den Tiefentest wieder.
Und da wir natürlich auch was von unserem Spiegelbild sehen woll und dies in den Farbpuffer gelangen soll, teilen wir OpenGL mittels {{INLINE_CODE|[[glColorMask]]()}} mit, dass wieder alle Farbkomponenten in den Farbpuffer gelangen sollen.

glStencilFunc(GL_EQUAL, 1, 1);

Mit dieser Zeile teilen wie OpenGL mit, das nur dort gezeichnet werden soll, wo sich im [[Schablonenpuffer|Stencilpuffer]] eine 1 befindet (siehe oben). Dies ist das "Geheimnis" hinter realistisch aussehenden Reflektionen im Stencilpuffer!

glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);

Nachdem wir unseren [[Schablonenpuffer|Stencilpuffer]] ja bereits mit einer unsichtbaren Spiegelmaske gefüllt haben, soll er von nun an nicht mehr verändert werden. In allen drei Testfällen wird der aktuelle Stencilwert deshalb also mittels '''GL_KEEP''' nicht mehr verändert.

glEnable(GL_CLIP_PLANE0);
glClipPlane(GL_CLIP_PLANE0, @ClipPlane);

Bevor wir jetzt dazu übergehen unsere gespiegelte Szene zu zeichnen, aktivieren wir noch die Schnittfläche unseres Spiegels. Die Erklärung dazu gabs ja bereits zum Beginn dieses Tutorials.

===Die gespiegelte Szene zeichnen===

So. Nachdem die Stencilpuffer-Tortur überstanden ist und mindestens die Hälfte der Leser eines unnatürlichen Todes gestorben sind, darf ich die anderen beglückwünschen. Wir sind fast fertig!

Nachdem unser [[Schablonenpuffer|Stencilpuffer]] also inzwischen die unsichtbare Spiegelfläche enthält und er auch schon für das Zeichnen der gespiegelten Szene vorbereitet wurde, müssen wir die Szene nur noch gespiegelt zeichnen. Nichts leichter als dass, denn mit [[glScale|glScalef]]() kann man eine Szene ja bekannterweise auf einfachste Art und Weise an einer Achse spiegeln.
In unserem Falle müssen wir die Szene an der Z-Achse spiegeln, also der Achse an der unser Spiegel spiegelt. Das geht dann kurz und schmerzlos :

glScalef(1,1,-1)

Wie gesagt...einfacher gehts nimmer. Wenn wir unsere Szene z.b. auf dem Fussboden spiegeln wollten, dann würe ein einfaches {{INLINE_CODE|glScalef(1,-1,1)}} reichen. Dass sieht in der Praxis dann im Endergebnis so aus :

{{center| [[Bild: Tutorial_Stencil_Trooper05.jpg]]}}

Anschliessend wird dann die Szene wie gewohnt gezeichnet. Wenn die Szene etwas komplexer ist, sollte man das Zeichnen in eine externe Prozedur auslagern, die man dann zweimal aufrufen muss.
Nicht vergessen : Vor dem skalieren der Matrix sollte man diese mit [[glPushMatrix]] auf den Matrizenstack legen, und vor dem Zeichnen der normalen Szene wieder mit '''glPopMatrix''' wiederherstellen!

glDisable(GL_CLIP_PLANE0);
glDisable(GL_STENCIL_TEST);

Nachdem wir unsere gespiegelte Szene gezeichnet haben, diese an der definierten Schnittfläche (wenn nötig) abgeschnitten wurde und aufgrund der Stencilmaske nur in die Spiegelfläche gezeichnet wurden, können sowohl die Schnittfläche als auch der Stenciltest wieder deaktiviert werden.

===Den Spiegel zeichnen===

<pascal>glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f(1,1,1,0.45);
MirrorTex.Bind;
DrawMirror;
glDisable(GL_BLEND);</pascal>

Nachdem wir nun unsere gespiegelte Szene hinter dem Spiegel gezeichnet haben, sollten wir noch unsere sichtbare Spiegelfläche zeichnen, um dem Spieler auch den Eindruck zu vermitteln, dass er vor einem Spiegel steht.Dazu benutze ich eine recht helle Glastextur, die ich mittels Alphablending über die gespiegelte Szene zeichne. Welchen Unterschied das macht, lässt sich auf folgenden beiden Screenshots (links ohne Spiegeltextur, rechts mit) sehr gut sehen :

{{center| [[Bild: Tutorial_Stencil_Trooper06.jpg]] [[Bild: Tutorial_Stencil_Trooper07.jpg]]}}

===Und die Moral von der Geschicht...===
...ohne die normale Szene dann zu rendern gehts nicht! Also nicht vergessen nach dem rendern des Spiegels auch noch die normale Spielszene zu zeichnen!

==Nachwort==

So...das war also mein erstes Tutorial für die DGL.Für mich wars halb so schlimm, während es für einige von euch wohl doch einem Vorschlaghammer auf den Hinterkopf gleich kam. Das macht aber nix, denn wenn irgendjemand etwas nicht verstanden hat, ich bin ja auch als Mod im Forum tätig und antworte gerne auf eure Fragen!

Abschliessend sei noch zu sagen, dass diese Technik einen Nachteil hat : Der Raum hinter der Spiegelfläche ist tabu, da man sonst einen Teil des illusionären Spiegelraumes dahinter sehen würde.Dieser Nachteil lässt sich jedoch recht leicht mit einigen Sichtbarkeitstechniken umschiffen, und der Nutzung solcher Spiegelungen sollte damit keine Grenzen mehr gesetzt sein!

Hoffe das Tut hat euch gefallen und vor allem auch geholfen!

Euer

'''[[User:Sascha Willems|Sascha Willems]]''' (webmaster AT delphigl.de)

==Nachtrag (Oktober 2005)==

Das Tutorial hat bereits einige Jahre auf dem Buckel, und in einer so schnellen Industrie wie der Grafikkartenindustrie ist das von größerer Bedeutung. Die Technik Spiegelungen mittels des Stencilpuffers zu realisieren ist heute kaum noch von Relevanz. Heute benutzt man so gut wie immer Render-To-Texture (z.B. via Pixelpuffer oder EXT_FBO) um Spiegelungen aller Art zu realisieren. Dadurch hat man diverse Vorteile :

* Die Spiegelung kann u.a. über Verschiebung der Mip-Maps schärfer bzw. dumpfer gemacht werden, so lassen sich auch einfach Reflektionen auf dumpfen Materialien wie z.B. verrostetes Metall darstellen.
* Die Spiegelung liegt in einer Textur vor. Damit verbunden sind jede Menge Manipulationen möglich, sei es nun so was grundlegendes wie Multitexturing oder erweitertes Sachen wie Shader. Mit Shadern kann man dann recht einfach solche Sachen wie Verwirbelung oder Refraktion auf der Oberflächen (u.a. für Wasser genutzt) realisieren.

Von daher sollte man heutzutage auf die Spiegelungsmethode im Stencilpuffer '''verzichten''' und die Render-To-Texture Methode verwenden.

'''[[User:Sascha Willems|Sascha Willems]]''' (webmaster AT delphigl.de)

{{TUTORIAL_NAVIGATION|[[Tutorial_MultiTexturing]]|[[Tutorial_StereoSehen]]}}
[[Kategorie:Tutorial|StencilSpiegel]]

glGetShaderSource

2008-04-03T08:05:50Z

Damadmax: Tippfehler bei glIsShader

= glGetShaderSource =

== Name ==
'''glGetShaderSource''' - Gibt den Sourcecode-String eines Shaderobjekts aus

 
== Delphi-Spezifikation ==

procedure '''glGetShaderSource'''(''shader'' : GLuint; ''bufSize'' : GLsizei
''length'' : PGLsizei; ''source'' : PGLchar)

== Parameter ==

{| border="1" rules="all"
! ''shader''
| Gibt das Shaderobjekt an, dass abgefragt werden soll.
|-
! ''bufSize''
| Gibt die Größe des Zeichenpuffers zu Speicherung des Sourcecode-Strings an.
|-
! ''length''
| Gibt die Länge des Strings (ausschließlich der Null-Terminierung), der nach ''source'' ausgegeben wurde, an.
|-
! ''source''
| Gibt ein Zeichen-Array an, in dem der Sourcecode-String abgelegt wird.
|}

== Beschreibung ==

'''glGetShaderSource''' gibt alle Sourcecode-Strings des Shaderobjekts ''shader'' auf einmal aus. Die Sourcecode-Strings eines Shaderobjekts sind das Ergebnis eiens vorhergehenden Aufrufs von [[glShaderSource]]. Der von der Funktion ausgegene String ist null-terminiert.

'''glGetShaderSorce''' gibt nach Source so viel wie möglich vom Sourcecode-String aus, bis maximal ''bufSize'' Zeichen. Die Anzahl der wirklich ausgegebenen Zeichen wird ausschließlich der Null-Terminierung durch ''length'' angegeben. Wenn die Länge des ausgegebenen Strings unerheblich ist, kann man im ''length''-Argument '''nil''' angeben. Die Größe des Puffers, der benötigt wird, den ausgebenen Sourcecode-String zu speichern, kann durch einen Aufruf von [[glGetShader]] mit dem Argument '''GL_SHADER_SOURCE_LENGTH''' bestimmt werden.

 

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

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

'''GL_INVALID_OPERATION''' wird generiert, wenn ''shader'' kein Shaderobjekt ist.

'''GL_INVALID_VALUE''' wird generiert, wenn ''bufSize'' kleiner 0 ist.

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

== Zugehörige Wertrückgaben ==
[[glGetShader]] mit Token [[glGetShader#GL_SHADER_SOURCE_LENGTH|GL_SHADER_SOURCE_LENGTH]]

[[glIsShader]]

== Siehe auch ==
[[glCreateShader]], [[glShaderSource]]

[[Kategorie:GL|GetShaderSource]]

glGetShaderInfoLog

2008-04-03T08:04:44Z

Damadmax: Tippfehler bei glIsShader

= glGetShaderInfoLog =

== Name ==
'''glGetShaderInfoLog''' - Gibt das Information-Log eines Shaderobjekts aus

 
== Delphi-Spezifikation ==

procedure '''glGetShaderInfoLog'''(''shader'' : GLuint; ''maxLength'' : GLsizei; ''length'' : PGLsizei; ''infoLog'' : PGLchar)

== Parameter ==

{| border="1" rules="all"
! ''shader''
| Gibt das Shaderobjekt an, dessen Information-Log abgefragt werden soll.
|-
! ''maxLength''
| Gibt die Größe des Zeichen-Puffers für das Speichern des erhaltenen Information-Logs an.
|-
! ''length''
| Gibt die Länge des Strings (ohne die Null-Terminierung) an, der nach ''infoLog'' ausgegeben wird.
|-
! ''infoLog''
| Gibt ein Zeichen-Array an, das verwendet wird, um das Information-Log auszugeben.
|}

== Beschreibung ==
'''glGetShaderInfoLog''' gibt das Information-Log für das spezifizierte Shaderobjekt aus. Das Information-Log eines Shaderobjekts wird verändert, wenn das Shaderobjekt gelinkt oder validiert wird. Der ausgegebene String ist null-terminiert.

'''glGetShaderInfoLog''' legt in ''infoLog'' maximal so viele Zeichen des Information-Log ab, wie durch ''maxLength'' angegeben wurde. Die Anzahl der ausgegebenen Zeichen - ausschließlich der Null-Terminierung - wird durch ''length'' angegeben. Wenn die Länge des ausgegenen Strings nicht von Interesse ist, kann '''nil''' als ''length''-Argument verwendet werden. Die Größe des Puffers, der zum Speichern des zurückgelieferten Information-Log verwendet wird, kann durch einen Aufruf von [[glGetShader]] mit dem Argument '''GL_INFO_LOG_LENGTH''', herausgefunden werden.

Das Information-Log für ein Shaderobjekt ist entweder ein leerer String oder ein String, der Informationen über die letzte Link- oder Validierungs-Operation enthält. Das Log kann Diagnose-Nachrichten, Warnungen und andere Informationen enthalten. Wenn ein Shaderobjekt erzeugt wird, ist sein Information-Log ein String mit der Länge 0.

 

== Hinweise ==
'''glGetShaderInfoLog''' ist nur in OpenGL-Versionen ab mindestens 2.0 verfügbar.

Das Information-Log für ein Shaderobjekt ist der wichtigste Weg der OpenGL-Implementation, Informationen über das Linken und Validieren mitzuteilen. Das Information-Log kann während dem Entwicklungsprozess hilfreich für Programmierer sein, auch wenn diese Operationen erfolgreich verlaufen. Man sollte aber nicht erwarten, dass verschiedene OpenGL-Implementationen (vor allem von verschiedenen Herstellern) identische Information-Logs liefern.

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

'''GL_INVALID_OPERATION''' wird generiert, wenn ''shader'' kein Shaderobjekt ist.

'''GL_INVALID_VALUE''' wird generiert, wenn ''maxLength'' kleiner 0 ist.

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

== Zugehörige Wertrückgaben ==
[[glGetShader]] mit Token [[glGetShader#GL_INFO_LOG_LENGTH|GL_INFO_LOG_LENGTH]]

[[glIsShader]]

== Siehe auch ==
[[glCompileShader]], [[glGetShaderInfoLog]], [[glLinkProgram]], [[glValidateProgram]]

[[Kategorie:GL|GetProgram]]

glGetShader

2008-04-03T08:03:45Z

Damadmax: Tippfehler bei glIsShader

= glGetShader =

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

 
== Delphi-Spezifikation ==

procedure '''glGetShader'''(''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]]

Diskussion:Tutorial Abseits eckiger Welten

2008-01-25T18:44:44Z

Damadmax: Die Seite wurde neu angelegt: Nachdem ich nun Tage damit verbracht habe herauszufinden warum meine Bezierfläche mit 7x10 Kontrollpunkten nicht funktioniert bzw einen GL_INVALID_VALUE Fehler erzeugt...

Nachdem ich nun Tage damit verbracht habe herauszufinden warum meine Bezierfläche mit 7x10 Kontrollpunkten nicht funktioniert bzw einen GL_INVALID_VALUE Fehler erzeugt, wollte ich mal anmerken, dass es an GL_MAX_EVAL_ORDER liegt. Auf meinem Rechner mit einer 8800GTS sind es ganze 8. Wobei ich mal davon ausgehe, dass es am Treiber liegt und wenn ich die Berechnung im Tutorial richtig verstanden habe, wäre das eine Funktion 7. Grades?

Kurzum. Ich fänd eine kleine Info wieviele Kontrollpunkte mindestens unterstützt werden im Tutorial für hilfreich.
--[[Benutzer:Damadmax|Damadmax]] 19:44, 25. Jan. 2008 (CET)

glEvalCoord

2008-01-04T00:26:56Z

Damadmax: Link zum Tutorial korrigiert

= glEvalCoord =

 
== Name ==
'''glEvalCoord1d, glEvalCoord1f, glEvalCoord2d, glEvalCoord2f, glEvalCoord1dv, glEvalCoord1fv, glEvalCoord2dv, glEvalCoord2fv''' - werten die aktivierten ein- und zweidimensionalen Karten ([[glMap1]]/[[glMap2]]) aus.

 
== Delphi-Spezifikation ==
procedure '''glEvalCoord1d'''(''u'': TGLdouble);
procedure '''glEvalCoord1f'''(''u'': TGLfloat);
procedure '''glEvalCoord2d'''(''u'': TGLdouble; ''v'': TGLdouble);
procedure '''glEvalCoord2f'''(''u'': TGLfloat; ''v'': TGLfloat);

== Parameter ==
{| border="1" rules="all"
! ''u''
| Legt den Wert für die Gebietskoordinate (engl.: domain coordinate) ''u'' fest, bezüglich der Basisfunktion die vorher mit [[glMap1]] oder [[glMap2]] gesetzt wurde.
|-
! ''v''
| Legt den Wert für die Gebietskoordinate ''v'' fest, bezüglich der Basisfunktion die vorher mit [[glMap2]] gesetzt wurde. Dieses Argument ist bei '''glEvalCoord1''' nicht vorhanden.
|}

== Delphi-Spezifikation ==
procedure '''glEvalCoord1dv'''(const ''u'': PGLdouble);
procedure '''glEvalCoord1fv'''(const ''u'': PGLfloat);
procedure '''glEvalCoord2dv'''(const ''u'': PGLdouble);
procedure '''glEvalCoord2fv'''(const ''u'': PGLfloat);

== Parameter ==
{| border="1" rules="all"
! ''u''
| Bestimmt einen Zeiger auf ein Feld welches entweder eine oder zwei Gebietskoordinaten enthält. Dier erste Koordinate repräsentiert immer ''u''. Die zweite Koordinate ist, falls vorhanden, ''v'' und wird nur bei den '''glEvalCoord2'''-Funktionen benötigt.
|}

 
== Beschreibung ==
{{Hinweis|Die Orginalspezifikation spricht von "Maps" also Karten. In der folgenden Beschreibung wird dieser Begriff durch "Bezierkurven" ersetzt. 2D-Maps entsprechen somit einem Raster/Fläche aus Bezierkurven.}}

'''glEvalCoord1''' wertet die aktivierte eindemensionale Bezierkurve an der Stelle ''u'' aus. '''glEvalCoord2''' tut das selbe mit zweidimensionalen Bezierkurve unter Benutzung von zwei Gebietswerten, ''u'' und ''v''. 
''Bezierkurven werden mittels [[glMap1]] bzw. [[glMap2]] erstellt und durch [[glEnable]]/[[glDisable]] aktiviert und deaktiviert.''

Wenn eine der '''glEvalCoord''' Funktionen ausgeführt wird, werden alle momentan aktiven Bezierkurven, welche die entsprechende Dimension haben, ausgewertet. Anschließend ist es für jede ausgewertete Karte so, als ob der zugehörige GL-Befehl aufgerufen worden wäre. Dies bedeutet, dass
* wenn GL_MAP1_INDEX oder GL_MAP2_INDEX aktiviert wurde, wird ein [[glIndex]] Befehl simuliert.
* wenn GL_MAP1_COLOR oder GL_MAP2_COLOR aktiviert wurde, wird ein [[glColor]] Befehl simuliert.
* wenn GL_MAP1_NORMAL oder GL_MAP2_NORMAL aktiviert wurde, wird ein Normalenvektor berechnet.
* wenn eine der Texurfunktionen (GL_MAP1_TEXTURE_COORD_1, GL_MAP1_TEXTURE_COORD_2, GL_MAP1_TEXTURE_COORD_3, GL_MAP1_TEXTURE_COORD_4, GL_MAP2_TEXTURE_COORD_1, GL_MAP2_TEXTURE_COORD_2, GL_MAP2_TEXTURE_COORD_3, oder GL_MAP2_TEXTURE_COORD_4) aktiviert wurde, wird ein entsprechender [[glTexCoord]] Befehl simuliert.

Die Farbe, Farbindex, Normale und Texturkoordinaten, werden jedes mal errechnet wenn die Berechunung für diese Werte aktiviert wurde (ansonsten werden die aktuellen Werte benutzt). Diese berechneten Werte überschreiben allerdings nicht die aktuelle Farbe, Farbindex, Normale oder Texturkoordiante. 
Das heißt, wenn [[glVertex]] Befehle mit '''glEvalCoord''' Befehlen durchsetzt sind, werden die Farbe, Normale und Texturkoordinaten die zu dem [[Vertex]] gehören nicht von den Werten beeinflußt, die durch die '''glEvalCoord''' Befehle erzeugt werden. Überschrieben werden diese Werte nur durch die dafür vorgesehen Befehle [[glColor]], [[glIndex]], [[glNormal]] und [[glTexCoord]].

Es werden keine Simulationen für Bezierkurven durchgeführt die nicht aktiv sind. Wenn mehr als eine Texturauswertung für eine bestimmte Dimension (zum Beispiel GL_MAP2_TEXTURE_COORD_1 and GL_MAP2_TEXTURE_COORD_2) aktiviert wurde, dann wird nur die Auswertung der Bezierkurve ausgeführt, welche die größere Anzahl an Koordinaten produziert (In diesem Beispiel also GL_MAP2_TEXTURE_COORD_2). Ähnlich verhält es sich mit anderen Funktionen. Es gilt:
*GL_MAP1_VERTEX_4 dominiert GL_MAP1_VERTEX_3
*GL_MAP2_VERTEX_4 dominiert GL_MAP2_VERTEX_3
Wenn weder eine drei- noch eine vier-Komponenten Vertexmap für die entsprechende Dimension aktiviert ist, wird der '''glEvalCoord''' Befehl ignoriert.

Wenn die automatische [[Normale]]n-Generierung durch einen Aufruf von [[glEnable]] mit dem Token GL_AUTO_NORMAL aktiviert ist, erstellt '''glEvalCoord2''' Oberflächennormalen analytisch, unabhängig vom Inhalt oder der Aktivierung der GL_MAP2_NORMAL Karte. Wenn

[[Bild:GlEvalCoord_LaTeX_Formel1.png|<nowiki>m = \frac{P_{p}}{P_{u}} \times \frac{P_{p}}{P_{v}}</nowiki>]]

Dann ist die generierte normale n gleich

[[Bild:GlEvalCoord_LaTeX_Formel2.png|<nowiki>n = \frac{-}{ \left \Vert m \right \| }</nowiki>]]

Wenn die automatische Normalengenerierung deaktiviert wurde, wird die zugehörige Normalenkarte GL_MAP2_NORMAL, falls aktiviert, genutzt um eine Normale herzustellen. Wenn weder die automatische Generierung noch die Normalenkarte aktiviert sind, generiert '''glEvalCoord2''' keine Normalen.

 

== Zugehörige Wertrückgaben ==
[[glIsEnabled]] mit Token GL_MAP1_VERTEX_3 
[[glIsEnabled]] mit Token GL_MAP1_VERTEX_4 
[[glIsEnabled]] mit Token GL_MAP1_INDEX 
[[glIsEnabled]] mit Token GL_MAP1_COLOR_4 
[[glIsEnabled]] mit Token GL_MAP1_NORMAL 
[[glIsEnabled]] mit Token GL_MAP1_TEXTURE_COORD_1 
[[glIsEnabled]] mit Token GL_MAP1_TEXTURE_COORD_2 
[[glIsEnabled]] mit Token GL_MAP1_TEXTURE_COORD_3 
[[glIsEnabled]] mit Token GL_MAP1_TEXTURE_COORD_4 
[[glIsEnabled]] mit Token GL_MAP2_VERTEX_3 
[[glIsEnabled]] mit Token GL_MAP2_VERTEX_4 
[[glIsEnabled]] mit Token GL_MAP2_INDEX 
[[glIsEnabled]] mit Token GL_MAP2_COLOR_4 
[[glIsEnabled]] mit Token GL_MAP2_NORMAL 
[[glIsEnabled]] mit Token GL_MAP2_TEXTURE_COORD_1 
[[glIsEnabled]] mit Token GL_MAP2_TEXTURE_COORD_2 
[[glIsEnabled]] mit Token GL_MAP2_TEXTURE_COORD_3 
[[glIsEnabled]] mit Token GL_MAP2_TEXTURE_COORD_4 
[[glIsEnabled]] mit Token GL_AUTO_NORMAL 
[[glGetMap]]

 

== Siehe auch ==
[[glBegin]], [[glColor]], [[glEnable]], [[glEvalMesh]], [[glEvalPoint]], [[glIndex]], [[glMap1]], [[glMap2]], [[glMapGrid]], [[glNormal]], [[glTexCoord]], [[glVertex]]

== Links ==
*[http://wiki.delphigl.com/index.php/Tutorial_Abseits_eckiger_Welten DGL Tutorial: Abseits eckiger Welten]

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

Benutzer:Damadmax

2007-11-10T16:50:10Z

Damadmax:

=Über mich=
''BETRETEN DER BAUSTELLE AUF EIGENE GEFAHR!''

=Testanwendungen=
Die ich in den vergangenen Monaten geschrieben habe.
==Landschaft==

Benutzer:Damadmax/monobook.css

2007-11-10T16:48:56Z

Damadmax: Die Seite wurde geleert.

Benutzer:Damadmax

2007-11-10T16:48:36Z

Damadmax:

= Über mich =
''BETRETEN DER BAUSTELLE AUF EIGENE GEFAHR!''

= Testanwendungen =
Die ich in den vergangenen Monaten geschrieben habe.
== Landschaft ==

Benutzer:Damadmax

2007-11-10T16:48:21Z

Damadmax:

''BETRETEN DER BAUSTELLE AUF EIGENE GEFAHR!''

= Über mich =

= Testanwendungen =
Die ich in den vergangenen Monaten geschrieben habe.
== Landschaft ==

Benutzer:Damadmax/monobook.css

2007-11-10T16:45:19Z

Damadmax: Die Seite wurde neu angelegt: table.toc {display:block;}

table.toc {display:block;}

Benutzer:Damadmax

2007-11-10T16:40:05Z

Damadmax: Die Seite wurde neu angelegt: ''BETRETEN DER BAUSTELLE AUF EIGENE GEFAHR!'' == Über mich == == Testanwendungen == Die ich in den vergangenen Monaten geschrieben habe. === Landschaft ===

''BETRETEN DER BAUSTELLE AUF EIGENE GEFAHR!''

== Über mich ==

== Testanwendungen ==
Die ich in den vergangenen Monaten geschrieben habe.
=== Landschaft ===