DGL Wiki - Benutzerbeiträge [de]

Diskussion:Blur

2006-10-30T05:06:35Z

Lyr:

Ich finde es ja sehr nett das jemand das Gaussian Blur etwas ausführlicher erklärt, aber den ein oder anderen Punkt habe ich doch noch zu bemängeln:

1. In einem Blur-Artikel sollte doch eine ganz ganz triviale Blur Matrix (oder ein Kernel wie man ihn auch immer bezeichnen will) auch drinnen sein, also das 1/9 für alle (Gleichberechtigung halt :-) ), hast du in deinem Gedankenexperiment kurz angeschnitten aber da es nicht nur ein Gedankenexperiment ist sondern auch in der Praxis häufig verwendet wird wäre es durchaus etwas detailierter erwähnenswert.

2. In der 2D-Gauss-Verteilung sollte es wohl weniger e^(...x²+x²...) heißen sondern e^(...x²+y²...) :-).

3. Bitte bitte vergleicht [[Motion-Blur]] nicht mehr mit stink normalen Blur ... obwohl es natürlich einen gewissen Zusammenhang gibt, passt er in diesen Artikel (bzw. in diesem Zusammenhang) meines Erachtens eher wenig rein.

Ansonnsten finde ich den Artikel wirklich nett, nur weiter so!

--[[Benutzer:Lyr|Lyr]] 06:06, 30. Okt 2006 (CET)

Motion-Blur

2006-10-30T04:59:50Z

Lyr: Mal eine erste Version ... Experte bin ich auch keiner

Motion Blur ist üblicherweise kein Effekt den man macht weil er schön ist, sondern ein Effekt der bei der Übertragung von digitalen Bildern zum menschlichen Auge eine Art Vermittlungsrolle spielt.

== Biologische Grundlagen ==
Das menschliche Auge nimmt etwa 25 Bilder je Sekunde wahr. Im Unterschied zur Computergrafik sind dies jedoch keine Momentaufnahmen sondern eine Art Aufsummierung aller Lichtreize die während dieser 1/25 Sekunde entstanden sind.

=== Ein leuchtender Punkt ===
Nehmen wir als Beispiel einen schwarzen Hintergrund. Über diesen schwarzen Hintergrund wandert (verhältnismäßig schnell) ein Licht. In der Computergrafik wenn wir beispielsweise 60 Frames pro Sekunde darstellen können würden wir 60 Momentaufnahmen darstellen, wobei in diesen Momentaufnahmen die Bewegung des Lichtpunktes keine Rolle spielen würde. Das menschliche Auge hingegen erhält nicht 25 Momentaufnahmen, sondern eine analoge Darstellung des Lichtsignales. Dieses analoge Lichtsignal wird nun (wie bereits erwähnt) während der gesamten 1/25 Sekunde aufsummiert und als solches an das Gehirn übertragen. Somit sehen wir nicht einzelne Momentaufnahmen des Lichtes sondern den gesamten Weg den das Licht zurückgelegt hat.

Wenn wir die Tatsache annehmen, dass wir nur 25 Bilder je Sekunde sehen, so können wir dies durch ein sehr einfaches Experiment nachvollziehen:

Begebt euch in einen möglichst dunklen Raum und vollführt mit einem Licht (zB Feuerzeug) verhältnismäßig schnelle Bewegungen. Ihr könnt nun den gesamten Weg sehen den das Licht zurückgelegt hat.

== Technische Umsetzung ==

=== Filme ===
Wenn ihr euch einen Film anseht, so scheinen die Bewegungen üblicherweise realer als in einem Computerspiel. Wenn ihr euch ein Standbild eines Filmes anseht so wird offensichtlich weshalb dies der Fall ist. Der Film besitzt üblicherweise zwar nur 25 Bilder je Sekunde jedoch besitzen diese Bilder (gleich zum menschlichen Auge) die aufsummierte Helligkeit der 1/25 Sekunde, was in einem Standbild durch Streifen sichtbar wird. Diese Streifen kann man nun als Idealfall von Motion Blur ansehen.

=== Computergrafik ===
In der Computergrafik stellt man üblicherweise Standbilder dar. Es wäre enorm aufwändig die Berechnungen durchzuführen welche Farbe und welche Helligkeit ein Pixel haben würde, würde es die letzte 1/25 Sekunde darstellen und nicht nur eine Momentaufnahme. Glücklicherweise ist der Mensch nicht ganz so wählerisch und begnügt sich auch mit etwas besseren Darstellungen seiner Wirklichkeit, somit ist es um einiges besser wenn man beispielsweise 60 Momentaufnahmen je Sekunde besitzt als wenn man nur 25 Momentaufnahmen besitzt.

== Motion Blur in der Praxis ==
Motion Blur ist also ein Effekt der das menschliche Auge möglichst zufriedenstellen soll. Bei verhältnismäßig langsamen Geschwindigkeiten (oder aber bei sehr hohen Frames je Sekunde) hat Motion Blur kaum bis keine Auswirkungen. Erst bei höheren Geschwindigkeiten kann Motion Blur sinnvoll eingesetzt werden. Hier geht es jedoch teilweise nicht nur darum allein das Standbild durch grafische Effekte zu verbessern, sondern im Idealfall geht es darum für jedes Pixel die vergangene 1/25 Sekunde zu beachten.

In Filmen sehen wir Motion Blur dann, wenn enorm hohe Geschwindigkeiten dargestellt werden sollen (annähernd Lichtgeschwindigkeit in Science Fiction Filmen). Obwohl ich weder ein Physiker noch ein Biologe bin, kann ich guten Gewissens behaupten, dass wir ein Raumschiff welches mit (annähernd) Lichtgeschwindigkeit an uns vorbei fliegt wohl so gut wie gar nicht sehen würden, da es nur einen sehr sehr kleinen Bruchteil einer 1/25 Sekunde sichtbar wäre ... einzige Ausnahme wäre natürlich wenn es enorm hell wäre, wodurch dieser sehr kleine Bruchteil viel bei der Aufsummierung der 1/25 Sekunde ausmachen könnte.

In der Computergrafik bezieht sich Motion Blur üblicherweise ausschließlich auf Momentaufnahmen wo die aktuelle Geschwindigkeit beachtet wird, oder aber die vorangegangenen Frames ebenfall einen Einfluss besitzen.

Diskussion:DelphiGL

2006-09-15T13:26:47Z

Lyr: /* Mitgliederentwicklung */

==Geschichte==

So wie's aussieht gab's hier wohl keine "frühsten Anfänge" ;-) Die DGL war auf einmal da :P

Ne, wäre echt schön, wenn hier einmal eine kleine Geschichtsbeschreibung ähnlich der für [[omwiki:Projektgeschichte|Projektgeschichte für Omorphia (ext)]] zu finden wäre.

Ich kann leider zu diesem Beitrag nichts selber beisteuern, da ich erst wesentlich später zur DGLC gekommen bin.

MfG, --[[Benutzer:BenBE|BenBE]] 21:05, 14. Dez 2005 (CET)

Das gibts ja jetzt ;)
Hab mir auch erlaubt, in dem Text von Phobeus ein paar Sachen, die mir fehlerhaft erschienen, zu ändern bzw. auszubessern.
Hab außerdem hier mal die Diskussionsseite bisschen formatiert.
--[[Benutzer:Luketheduke|luketheduke]] 15:19, 30. Mai 2006 (CEST)

==Mitgliederentwicklung==
Hallo, bei der Bildunterschrift zum Diagramm "Mitgliederentwicklung" kann ich mit den Zahlen "18.09", "21.83" und "25.83" kaum was anfangen. Trennpunkte müssten ja wohl beim Tausender-Schritt stehen ("1.809"), und Dezimalstellen kommen mir 1. unwahrscheinlich vor und 2. im Deutschen bitte ein Komma. Oder zumindest einen Hinweis.

--[[Benutzer:Luketheduke|luketheduke]] 12:11, 2. Apr 2006 (CEST)

Da steht doch monatliches Wachstum 18.09 Mitglieder. Das heißt soviel wie, pro Monat wächst die Comunity um 18 Mitglieder.

----

Wäre vielleicht noch interessant die aktiven Mitglieder einzutragen. Aktiv könnte man hiebei als: "Hat in den letzten X Monaten einen Forenbeitrag geschrieben", "War in den letzten X Monaten einmal eingeloggt" oder ähnlich definieren. Weil die Anzahl der Benutzer, egal ob sie überhaupt mal eingeloggt haben oder nicht, sagt nicht wirklich allzu viel aus. Ist historisch wohl nicht so leicht zu machen (vor allem wenn man das letzte einloggen als aktiv definiert) aber man könnte ja mal damit anfangen.

--[[Benutzer:Lyr|Lyr]] 15:26, 15. Sep 2006 (CEST)

== Allgemein (Aus Diskussion zum Vorschlag für Exzellente Artikel) ==

Kann mich Flash und Lyr in Bezug auf den [[DelphiGL]]-Artikel nur anschließen. Außerdem würde ich in Bezug auf die Gestaltung 2 Dinge bemängeln, die als zwingende Vorgaben zu sehen sind:
#Als Illustration werte ich keinesfalls das zeigen eines Graphen, der die Mitgliederzahl in Abhängigkeit von der Zeit enthält, oder Tabellen, die deren erste Ableitung enthalten. Außerdem ist der Verweis auf die Mitgliederkarte zwar sinnvoll, ist aber auch etwas "lieblos" im Artikel reingeschmissen. Der Artikel muss also in Hinblick auf die äußere (gleichmäßige) Formatierung\Gestaltung auf jeden Fall überarbeitet werden.
#Zweitens zweifle ich stark die Vollständigkeit dieses Artikels an. Es gibt nämlich nicht nur die frühsten Anfänge und ein Jetzt, sondern auch (2-3 Jahre) dazwischen, die mir in diesem Artikel teilweise (bis ganz) fehlen. Auch ist der unter [[DelphiGL#Historie_im_Überblick]] gezeigte Zeitgraph an relativ vielen Stellen relativ weiß, was IMHO nicht für dessen Vollständigkeit spricht. Weiterhin fehlt in Bezug auf die Aprilscherze, die angeführt werden, die Informationen für die Jahre 2003 und 2004.
Insgesamt gefällt mir der Artikel also aus folgenden Gründen nicht:
#Aufmachung und Layout-Gestaltung
#Präsentation\Gliederung der Informationen
#Vollständigkeit der dargebrachten informationen
--[[Benutzer:BenBE|BenBE]] 18:12, 1. Jul 2006 (CEST)

Diskussion:Level of Detail

2006-09-11T20:00:44Z

Lyr:

Sind VIPMs = VDPMs?
Auf jeden Fall nochmal die Links im Artikel und der LOD-Übersicht im Techniken-teil checken.
Eventuell wurden VIPMs doppelt aufgeführt.
--[[Benutzer:Flash (Kevin Fleischer)|Flash (Kevin Fleischer)]] 14:47, 21. Jan 2005 (CET)

Bin ich auch etwas spät dran aber gerade darüber gestoßen:

Nein VIPM ist nicht gleich VDPM das eine heißt View independent -, das andere View dependent - progressive Meshes. Obwohl beide recht ähnlich klingen, teilweise auf ähnlichen Ideen basieren und sogar von der selben Person stammen verfolgen sie doch 2 komplett unterschiedliche Ansätze. VDPMs sind nur bei weiterm nicht so populär geworden wie VIPMs, weil VDPMs (wie man durch den kleinen Unterschied im Namen vielleicht schon erkennen kann) doch eher CPU-lastig sind. Wenns jemanden interessiert (und vielleicht schreibt ja auch jemand was darüber) hier findet man das Paper:

http://research.microsoft.com/~hoppe/

View-dependent refinement of progressive meshes.

--[[Benutzer:Lyr|Lyr]] 22:00, 11. Sep 2006 (CEST)

Diskussion:Triangulation

2006-09-08T03:36:02Z

Lyr:

@Flash: ich nehme an bei dem Artikel hast du auch einiges aus dem Uni-Script? :-).

Das triangulieren passiert auf der Grafikkarte und dort ist es nicht mehr und nicht weniger als ein paar Vertices doppelt zu verwenden. Bei lauter Dreiecken hat man also irgend etwas wie:
for i = 1 bis Punkte: zeichne Dreieck( Punkt[i], Punkt[i+1], Punkt[i+2] ); i += 3;
Bei einem Triangle Strip etwa:
for i = 1 bis Punkte-2: zeichne Dreieck( Punkt[i], Punkt[i+1], Punkt[i+2] ); i += 1;
Bei einem Quad, Triangle Fan und natürlich auch bei einem Polygon sieht das nicht viel anders aus. Das ist natürlich irgendwie in Hardware implementiert aber da bin ich nicht so der Spezialist dafür. Dennoch ... wenn mir irgend jemand einreden möchte, dass die 2. Variante relevant länger braucht als die 1ste, dann sollte er dafür schon gute Gründe haben. Und bei der 2. Variante sparen wir natürlich viel Bandbreite auf unserem AGP Bus.

Also wenn man in Bezug auf OGL von Triangulation spricht, dann ist das eine der einfachsten Sachen der Welt. Wenn man von konkaven Polygonen (oder was auch immer) und Triangulation spricht, dann spricht man nicht mehr von OGL, weil OGL kann das nicht.

Wollte schon anfangen den Artikel um zu schreiben, aber irgendwie wird das dann bei mir ein 5 Zeiler oder sowas, das wollte ich dann auch wieder nicht ... also vielleicht lässt sich ja jemand einen schön ausgeschmückten 10-Zeiligen Text einfallen :-).

--[[Benutzer:Lyr|Lyr]] 16:20, 7. Sep 2006 (CEST)

Nun das Wiki ist zwar OGL orientiert, aber hier gehts durchaus auch um techniken der allgemeinen Computergrafik.

--[[Benutzer:Flash|Flash]] 16:54, 7. Sep 2006 (CEST)

Stimmt schon, aber ich finde den Artikel halt etwas irritierend. Da heißt es zum einen: "Wenn ihr die Möglichkeit habt, dann baut eure Szene von Anfang an aus Dreiecken auf." was ich zu Beginn (bevor ich weiter las) so aufgefasst habe, dass man keine (konvexen) Polygone, Quads, Triangle-Strips und -Fans verwenden soll sondern Dreiecke, was natürlich üblicherweise falsch ist. Weiter unten heißt es dann aber doch dass man Tri-Strips und -Fans verwenden soll und da Polygon = Triangle Fan und Quad ~= Triangle Strip mit 4 Punkten bleibt für den obigen Satz (über das aufteilen in Dreiecke) nur noch die Vermutung dass da konkave Polygone gemeint sind. Über konkave Polygone wiederum steht nirgends etwas.

Das Problem mit dem Begriff Triangulation (wenn er nicht nur auf OGL bezogen sein soll) ist wohl der, dass er für ziemlich alles verwendet werden kann was irgendwie mit dem zerlegen von irgendwelchen Daten in Dreiecke zu tun hat. Daten können hier konvexe oder konkave Polygone sein, irgendwelche beliebigen Punktmengen die die Oberfläche eines Objektes beschreiben und was weiß ich noch alles. Wahrscheinlich wäre der Begriff auch dann angebracht wenn man ein teilweise transparentes Volumen (zB Rauch) mit Dreiecken darstellen möchte. Im Internet findet man unter diesem Begriff alles mögliche.

Ich habe jetzt auch mal die OGL-Spec nach dem Begriff Triangulation zu durchforstet, der kommt dort genau einmal vor nämlich da wo gesagt wird das man ein Polygon (für den Rasterizer) auch in Dreiecke zerlegen darf.

Das beste wäre es also vielleicht wenn man den Titel in Polygon Triangulation ändert und dann etwas von konkaven Polygonen erzählt und überhaupt nicht auf OGL eingeht, oder vielleicht noch ganz kurz die Anmerkung dass man das zerlegen eines Triangle-Strips, -Fans, Quads oder (konvexen) Polygon auch als Triangulation bezeichnen kann. Aber das mit der Geschwindigkeit sollte man halt ganz weg lassen oder vielleicht noch anmerken das Triangle-Strips, -Fans, ... schneller sind als einzelne Dreiecke (wegen Bandbreite).

--[[Benutzer:Lyr|Lyr]] 05:36, 8. Sep 2006 (CEST)

Diskussion:glBegin

2006-09-08T03:25:21Z

Lyr:

Ich finde das die 2te spalte ziemlich gequetscht aussieht. Besonders wenn man den Browser nicht maximiert hat. Weiß allerdings nicht wie das am besten zu lösen ist.
(Meine Auflösung ist: 1024 x 768)

Habs umformatiert. Jetzt besser?

--[[Benutzer:Flash|Flash]] 14:28, 16. Jun 2006 (CEST)

== Lyrs ergänzung zu GL_POLYGON ==

Die Ergänzung ist mir erst jetzt aufgefallen.
Könntest du vielleicht noch ein 2 Sätze dazu erklären? Die Sachen die Ich reingeschrieben hab kamen aus nem UniScript von mir. Aber kann durchaus sein, dass da Optimierungen ausen vor gelassen wurden.

--[[Benutzer:Flash|Flash]] 13:36, 6. Sep 2006 (CEST)

Uni-Script als OGL-Referenz ... uiuiui du traust dich was :-).

Uni-Theorie ist meist (bei mir wars zumindest so), dass ein Polygon auch konkav sein darf und diese Annahme übertragen sie dann gleich auf OpenGL. In OGL darf ein Treiber GL_POLYGON exakt gleich berechnen wie Triangle Fans. Ist ja auch hier sogar genau das selbe Bild bei beiden Varianten, und das nicht umsonnst denn sie sind auch gleich. Ich habe das zur Sicherheit damals auch ausprobiert, GL_POLYGON und GL_TRIANGLE_FAN waren bei mir ''exakt'' gleich schnell, so gleich das ich annehme, dass es ein und derselbe Funktionsaufruf ist (oder zumindest eine komplett identische Funktion). Nur wenn man in Wireframe zeichnet, dann ist natürlich GL_POLYGON ein klein wenig schneller, weil er weniger Linien zeichnen muss (nur den Rand nicht die Linien der Dreiecksgrenzen).

Dein Verständnisproblem liegt aber möglicherweise schon beim triangulieren wie mir gerade auffällt. Da diese Erörterung wohl eher dort rein passt, lies am besten auch dort weiter.

--[[Benutzer:Lyr|Lyr]] 16:22, 7. Sep 2006 (CEST)

Also gibt es keine unterschiede zwischen GL_POLYGON und GL_TRIANGLE_FAN? Dann frag ich mich wieso immer wieder gesagt wird, GL_POLYGON sei extrem langsam. Ob das früher mal so war und das mittlerweile durch intelligente Treiber erledigt ist?
--[[Benutzer:Flash|Flash]] 16:56, 7. Sep 2006 (CEST)

Also soweit ich die OGL-Spec verstehe ''kann'' es Unterschiede beim Rasterizer geben, also das die Interpolation der Farbwerte etwas "besser" berechnet wird als beim Triangle Fan. Wäre mir aber noch nie aufgefallen, also dieses "kann" wird wohl von den wenigsten Treibern wahr genommen. Habe ich aber auch nicht so sehr getestet.

Intelligentere Treiber? Nein, eher das Gegenteil. Möglicherweise war es früher so das die Farb- und Textur-Interpolation im Zeitalter von 2D-Grafik bei Polygonen besser war als beim Triangle Fan. Vielleicht ist es auch heute bei Grafikkarten die mehr auf 2D ausgelegt sind noch so (falls es soetwas noch gibt :-) ). Wie gesagt, am besten ausprobieren, ich habe damals nur recht triviale Polygone und Triangle-Fans zum testen verwendet (also ohne Textur und dergleichen). Aber ich bezweifle stark dass man auf mehr als sagen wir mal 5% der Grafikkarten einen merkbaren Unterschied (sowohl was Geschwindigkeit als auch Aussehen betrifft) erkennt.

"Dann frag ich mich wieso immer wieder gesagt wird, GL_POLYGON sei extrem langsam."

Das ist wohl etwas was man einmal hört und dann den "Newbies" unter die Nase reibt das man sich besser auskennt als sie, wodurch die "Newbies" dass dann später den anderen unter die Nase reiben. Also fang ich jetzt mal an den Leuten unter die Nase zu reiben, dass sie sich doch nicht besser auskennen :-).

--[[Benutzer:Lyr|Lyr]] 05:25, 8. Sep 2006 (CEST)

Diskussion:glBegin

2006-09-07T14:22:04Z

Lyr:

Diskussion:Triangulation

2006-09-07T14:20:05Z

Lyr: ist etwas ... missverständlich

Diskussion:Blenderexporter

2006-07-19T11:53:37Z

Lyr: Das mit dem Hauptseite/_Kategorie:Trampelpfad_/Enginepfad ... hat wohl nicht so toll hin gehauen.

Denke mal der Artikel kann dan den Artikel [[Blenderscript]] ablösen. Interessant wäre vorallem wie man das exportierte Modell dan wieder laden kann.

Bitte verlinke den neuen Artikel dann gut im Wiki! Der Alte konnte nur über [[Hauptseite]]/Trampelpfad/[[Enginepfad]]/[[Leveleditoren]]/[[Blenderscript]] ereicht werden

Hintergrundwissen

2006-07-19T10:45:54Z

Lyr: /* Sonstiges */ + Vertex Cache

== Was hier hinein gehört ==

In diese Kategorie kommt alles rein was zum Verständnis im Bereich OpenGL/3D-Programmierung nützlich sein könnte. Also u.a. welche Puffer es unter OpenGL gibt, und für was die gut sind.

Auch hier sollte man möglichst aufspalten und dann eine Überschrift setzen. So macht man das Auffinden bestimmter Dinge leichter und auch die Verlinkung darauf ist oft etwas das man in anderen Dokumenten benötigt.

P.S. : Ob hier Deutsche Begriffe oder Anglizismen genutzt werden ist jedem selbst überlassen. Ich persönlich bevorzuge ersteres.

== Begriffserklärungen ==
In diesem Teil findet ihr Erklärungen zu begriffen, die ihr ständig im Zusammenhang mit OpenGL höhrt. Wenn ihr etwas nicht kennt, könnt ihr hier nachsehen, ob der Begriff bereits erklärt wurde.

=== Grundlagen ===
: [[Funktions Anhang|Aufbau von OpenGL Funktionen]]
: [[Bounding Volume]] ([[Bounding Box]])
: [[Clipping Plane]] {{excIcon}} (Schnittebenen)
: [[Frustum]]
: [[Matrix|Matrix / Matrizen]]
: [[OpenGL Name|Namen in OpenGL]]
: [[Normalen]]
: [[Primitive]]
: [[Texel]] {{icpIcon}}

=== Bildentstehung ===
: [[Dithering]] {{icpIcon}}
: [[Fragment| Fragmente]]
: [[Pixel]]
: [[Rasterisierung]]
: [[Tiefentest]]

=== Puffer ===
: [[Akkumulationspuffer]] (Accumulationbuffer)
: [[Doppelpufferung]] (Doublebuffering)
: [[Farbpuffer]] (Colorbuffer)
: [[Feedbackpuffer]]
: [[Framebuffer]]
: [[Logischer Puffer]]
: [[Schablonenpuffer]] (Stencilbuffer)
: [[Selektionspuffer]]
: [[Tiefenpuffer]] (Depthbuffer)

=== Texturen ===
: [[Decals]]
: [[MipMaps]]
: [[Register Combiner]]
: [[Texel Berechnung]]
: [[Texturen]]

=== Textureneffekte ===
: [[Animierte Textur]]en
: [[Bumpmapping]] (Simulation rauher Oberflächen)
: [[Displacementmapping]] (Änderung der Oberflächengeometrie)
: [[Detailmapping]] (Erhöhung des Texturdetailgrades)
: [[Environment Mapping]] (Umgebungsspiegelung)
:: [[Cubemap]]ping {{icpIcon}}
:: [[Spheremap]]ping {{icpIcon}}
: [[Multitexturing]]
: [[Texture Stage]]

=== Effekte ===
: [[Antialiasing]] (Kantenglättung)
: [[Blenden]] (Blending)
: [[Jittering]] (Verwischen)
: [[Nebel]] (Fogging)
: [[Transparenz]] (durchsichtige Objekte)

=== Optimierungen ===
: [[Backfaceculling]]
: [[Displaylisten]]
: [[Frustum Culling]]
: [[Triangulation]]
: [[VBO]] (Vertex Buffer Objects)

=== Weiterführendes ===
: [[Beleuchtung]]
: [[Billboard]]s
:: [[sphärisches Billboard]] {{icpIcon}}
:: [[zylindrisches Billboard]] {{icpIcon}}
: [[Convolution]]
: [[NURBS]]
: [[Picking]]
: [[Point Sprite]]
: [[Quadrik]]en
: [[Selektion]]
: [[Sprite]]s
: [[Tesselierung]]

=== Fehler/ Nebeneffekte ===
: [[Aliasing]] (Treppenbildung und Ähnliches)
: [[Popping]] (Plötzliches Auftauchen von Elementen. Z.B. bekannt bei [[LOD]])
: [[ZFighting]] (Flimmernde Polygone und Kanten)

=== Render-Pipeline ===
: [[Feste Funktionspipeline]] {{icpIcon}}
: [[GLSlang]]
: [[GLSL]]
: [[Shader]] (allgemein)
:: [[Fragmentshader]]
:: [[Vertexshader]]

=== Bibliotheken ===
: [[DGLSDK]]
: [[OpenAL]]
: [[SDL]]

=== Sonstiges ===
: [[Benchmark]]
: [[Callback]]
: [[Füllrate]]
: [[Renderkontext]]
: [[Scanlinerenderer]]
: [[Timebased Movement]]
: [[Vertexlimitiert]]
: [[Shaderlimitiert]]
: [[Bandbreitenlimitiert]]
: [[Vertex Cache]]

=== Bücher zum Thema ... ===
: ... OpenGL: [[RedBook]]
: ... OpenGL: [[BlueBook]]
: ... OpenGL: [[PurpleBook]]
: ... OpenGL: [[OrangeBook]]
: ... OpenGL: [http://www.starstonesoftware.com/OpenGL/ OpenGL Superbible]

== Checklisten ==
In diesem Teil findet ihr Checklisten die ihr durcharbeiten solltet, wenn ihr Fehler im Code habt, bzw. wenn eure Ausgabe nicht so aussieht wie sie es söllte.

:[[Checkliste Blending]]
:[[Checkliste Positionierung]]
:[[Checkliste Selektion]]
:[[Checkliste Shader]]
:[[Checkliste Texturierung]]

Vertex Cache

2006-07-19T10:45:47Z

Lyr:

Vor allem bei [[Vertexgebunden]]en Applikationen sollte man darauf achten den Vertex Cache möglichst effektiv zu nützen. Der Vertex Cache - oder Transform & Lighting Cache - wird unterteilt in Pre- und Post-T&L-Cache.

==Pre-T&L-Cache==
Der Pre-T&L-Cache ist vergleichbar mit dem Cache der CPU. Wenn wir mit der CPU auf ein Byte im RAM zugreiffen, so wird ja bekanntlich der gesamte Block (in dem sich das gesuchte Byte befindet) im Cache abgelegt. Wenn nun auf Bytes im selben Block zugegriffen wird, so befinden sich diese bereits im Cache und dieser erlaubt einen schnellen Zugriff. Auf sehr ähnliche Weise funktioniert der Pre-T&L-Cache. Wenn wir einen größeren Array von [[Vertex|Vertices]] besitzen und über eine Index-Liste darauf zugreifen, so bewirkt ein Zugriff auf einen [[Vertex]] nicht nur das holen des gesuchten Vertex, sondern der gesamte Block in dem sich der [[Vertex]] befindet wird in den Pre-T&L-Cache geladen. Wird nun solange dieser Block im Cache liegt ein Index angegeben, welcher einen [[Vertex]] im selben Block referenziert, so kann dieser [[Vertex]] sehr schnell aus dem Cache ausgelesen werden.

===Cache-Größe===
Der Pre-T&L-Cache ist üblicherweise verhältnismäßig groß. Einige Beispiele:
* GeForce FX 3000: ~8,000 [[Vertex|Vertices]]
* GeForce FX 6800: ~64,000 [[Vertex|Vertices]]

===Hinweise zur Performance===
Bei diesem Cache können nur begrenzt allgemein gültige Hinweise zur Performance gegeben werden, da verschiedene Grafikkarten unterschiedliche Strategien und Implementierungen besitzen können. Üblicherweise sollten jedoch folgende Punkte beachtet werden:
* Verhältnismäßig sequenzielle Zugriffe auf einen [[Vertex]]-Array sind wünschenswert.
* [[Vertex]]-Array-Blöcke die zu groß für den Cache sind können sich negativ auswirken, vor allem bei eher wenigen sequenziellen Zugriffen.
* Mehrere [[Vertex]]-Daten-Streams können sich negativ auswirken, wodurch meistens verschachtelte Streams (siehe [[glInterleavedArrays]]) vorzuziehen sind. Wenn jedoch beispielsweise die [[Vertex]]-Daten statisch sind jedoch die Farbwerte oder Texturcoordinaten dynamisch, so ist es natürlich dennoch besser wenn die [[Vertex]]-Daten getrennt im GPU-Speicher abgelegt werden.
* Vor allem bei eher nicht sequenziellen Zugriffen ist es üblicherweise hilfreich wenn die Daten für einen [[Vertex]] eine "gut handhabbare" Größe besitzen (üblicherweise 32 Byte).

==Post-T&L-Cache==
Der Post-T&L-Cache dient dazu um Ergebnisse der [[Feste Funktionspipeline#Vertex Pipeline|Vertex-Pipeline]] zu speichern. Wenn ein vor kurzem berechneter [[Vertex]] identisch ist mit dem zu berechnenden [[Vertex]], so wird das gespeicherte Ergebnis verwendet und somit muss dieser [[Vertex]] die [[Feste Funktionspipeline#Vertex Pipeline|Vertex-Pipeline]] nicht mehr durchlaufen. Zu beachten ist, dass dieser Cache üblicherweise als FIFO (First in first out) realisiert ist und nicht der für Cache-Systeme gängigere LRU (Least recently used) Algorithmus verwendet wird.

===Cache-Größe===
Die größe dieses Caches ist üblicherweise stark begrenzt. Einige Beispiele:
* GeForce 1&2: 16 [[Vertex|Vertices]]
* GeForce 3: 24 [[Vertex|Vertices]]

===Hinweise zur Performance===
Hier sollte man nur darauf achten, dass gleiche [[Vertex|Vertices]] möglichst schnell hintereinander verwendet werden. Das typische Beispiel hierfür ist ein 2 dimensionales Gitternetz (beispeilsweise eine [[Heightmap]]) bei dem immer ein Streifen mit einem Triangle-Strip gezeichnet wird. Besitzen wir beispielsweise einen Vertex-Cache mit 16 Einträgen, so ist die optimale größe für einen Triangle-Strip 7 Vierecke (wofür wir genau 16 Eckpunkte benötigen). Zeichen wir nun den darunter liegenden Streifen, wo die Hälfte der Punkte mit dem oberen Streifen geteilt werden, so wird für jeden zweiten Punkt der Vertex-Cache verwendet. Werden hingegen 8 Vierecke je Streifen gezeichnet, so wird der Vertex-Cache überhaupt nicht verwendet. Wenn man also mehr als 7 Vierecke je Streifen besitzt, so ist es besser man zeichnet den ersten Streifen von links nach rechts und den zweiten Streifen von rechts nach links usw., wodurch wenigstens ein Teil der Punkte noch im Vertex-Cache zu finden ist.

==Referenzen==
* [http://www.ati.com/developer/dx9/ATI-DX9_Optimization.pdf Performance Optimization Techniques for ATI Graphics Hardware with DirectX® 9.0]

Framebuffer

2006-07-12T04:15:57Z

Lyr: Vor allem wegen der häufig missverständlichen Verwendung von "Fragment" ziemlich stark umformuliert.

Bevor das Bild, welches man rendert, auf dem Monitor sichtbar wird, wird es in den so genannten Framebuffer geschrieben. Im Framebuffer wird nicht nur die Farbe eines Bildpunktes gespeichert, sondern auch dessen Tiefe und/oder dessen Stencil-Wert.

Wenn ein Objekt gezeichnet wird, so muss sowohl der Tiefentest (welcher seine Daten vom [[Tiefenpuffer]] und von der Tiefe des zu prüfenden [[Fragment]]es bezieht) als auch der Stencil-Test (welcher seine Daten aus dem [[Schablonenpuffer]] und vom Stencil-Wert des zu prüfenden [[Fragment]]es bezieht) bestanden werden, damit die Daten im [[Farbpuffer]] landen. Der Tiefen- und Stencil-Test kann natürlich aktiviert oder deaktiviert werden. Voraussetzung für beide Tests ist aber natürlich das Vorhandensein der Puffer, welches durch das gewählte [[Pixelformat]] (gesetzt durch [[WGL ARB pixel format]] bzw. [[SetPixelFormat]]) gewährleistet sein muss.

==Die Bildentstehung im Framebuffer==

Wenn ein (das erste) Objekt gezeichnet wird, so wird der Colorbuffer an diesen Stellen beschrieben. Ebenso der [[Tiefenpuffer]]. Vor dem erneuten schreiben in den Framebuffer wird nun überprüft, ob die Tiefenkoordinaten der [[Fragment|Fragmente]] des neuen Objektes den [[Tiefentest]] bestehen (üblicherweise muss der Tiefenwert dafür kleiner - also näher - sein als der bereits existierende Wert im Framebuffer). Dieser Vorgang wiederholt sich bis alle Objekte gezeichnet wurden. Das Bild liegt nun fertig im Framebuffer und kann auf dem Bildschirm angezeigt werden.

Ähnlich wie der [[Tiefenpuffer]] können auch die Stencil-Werte mit dem [[Schablonenpuffer]] verglichen werden. Das verhalten von beiden Tests kann mittels [[glDepthFunc]] bzw. [[glStencilFunc]] verändert werden.

Der Framebuffer funktioniert nach dem so genannten [[Doppelpufferung|Doublebuffering]]prinzip.

Farbpuffer

2006-07-12T03:39:13Z

Lyr: RGB_A_ ist meines Wissens nicht Pflicht und vor allem auf älteren Karten auch nicht so sehr in Hardware vertreten.

== Was ist der Farbpuffer? ==
Der Farbpuffer enthält die Farbinformationen im [[Framebuffer]]. Gespeichert werden dazu je nach Modus entweder Indizes auf Paletteneinträgte (Index-Modus) oder Intensitäts-Werte der Pufferkomponenten (RGB(A)-Modus).

== Aufbau ==

=== RGBA-Modus ===
Hat man einen Renderkontext mit mehr als 8-Bit Farbwerten (8-Bit = 256 Farben = Indexmodus) angefordert, bekommt man von OpenGL einen sog. RGB- oder RGBA-Farbpuffer (R=Rot, G=Grün, B=Blau, A=Alpha) zur verfügung gestellt. Der Farbpuffer besteht dann aus insgesamt 3 oder 4 unabhängigen Puffern für jede RGB(A)-Komponente, deren Bit-Tiefe von der gewählten Farbtiefe abhängt. Im Normalfall (32-Bit Farbtiefe, 24 Bit für R+G+B und 8 Bit für A) besitzt jeder dieser Komponentenpuffer 8 Bitflächen, in denen die Intensität der entsprechenden Komponente als Ganzzahlwert abgelegt wird. Die Intensität reicht dabei von 0 (entspricht 0/255) bis 255 (entspricht 1.0, also volle Intensität).
Die Alpha-Komponente kann mittels [[Blending]]/[[Alphamasking]] für verschiedene Transparenz-Effekte verwendet werden.

Wenn man sich unter Windows ein Pixelformat besorgt, werden die Bits aus '''cColorBits''' auf Rot, Grün und Blau verteilt. Der Wert von '''cAlphaBits''' gibt dagegen die Bits für den Alpha Kanal an.

=== Index-Modus ===
Dieser Modus wird heute nur noch sehr selten verwendet, denn 256-Palettenfarben sind inzwischen einfach viel zu wenig, aber mehr war damals aufgrund eingeschränkter Hardware einfach nicht machbar. In diesem Modus gibt man (im Normalfall beim Programmstart) eine Farbpalette an, in der sich alle benötigten Farbwerte befinden. Jeder dieser Farbwerte besitzt eine eindeutige Nummer, den Index. OpenGL schreibt in diesem Modus dann nicht die Intensität der Farbkomponente in den Farbpuffer, sondern einfach nur den Index dieser Farbe, so dass diese später referenziert werden kann.

== Wichtige Funktionen ==
Wie auch die anderen Buffer kann der Colorbuffer über die Funktion [[glClear]] und dem Parameter '''GL_COLOR_BUFFER_BIT''' mit einem Wert gefüllt werden.
Dieser Farbwert wird mit Hilfe der Funktion [[glClearColor]] definiert.
Farbwerte für einzelne [[Eckpunkt|Eckpunkte]] übergibt man mittels [[glColor]].

== Siehe auch ==
[[Tiefenpuffer]], [[Schablonenpuffer]], [[Akkumulationspuffer]]

Fragment

2006-07-11T12:33:00Z

Lyr:

Ein [[Primitive]] welches gezeichnet werden soll wird vom Rasterizer (siehe [[Feste Funktionspipeline#Fragment Pipeline|Fragment Pipeline]]) in Fragmente zerlegt. Jedes Fragment durchläuft die [[Feste Funktionspipeline#Fragment Pipeline|Fragment Pipeline]] und landet nach mehreren bestandenen Tests als [[Pixel]] im [[Framebuffer]]. Ein Fragment besitzt dabei vor allem folgende Daten:
* Fensterposition
* Tiefe
* Farbwert(e) oder Farbindex
* Alphawert
* Texturcoordinate(n)
* Stencilwert
Die Daten können (beispielsweise durch einen [[Fragment Shader]], Nebelberechnungen, ...) während der Lebensdauer eines Fragmentes noch verändert werden. Zusätzlich kann jeder Test ([[Tiefentest]], Alphatest, ...) ein Fragment verwerfen.

Diskussion:Fragment

2006-07-10T22:52:00Z

Lyr:

Ich dachte eigentlich, dass Fragmente die "Dinger" sind die vom Rasterizer erzeugt werden, und nicht die Werte die im Frame-Buffer aktuell zu finden sind. In diesem Fall würden sie noch etwas mehr Informationen beinhalten wie beispielsweise Texturkoordinaten. Bin mir ziemlich sicher das man diese "Dinger" ''auch'' als Fragmente bezeichnet, aber nicht 100% sicher ob man die Werte im Framebuffer ''nicht'' als Fragmente bezeichnet. Wenn man diese nicht als Fragmente bezeichnet (was ich wie gesagt glaube) sollte man den gesamten Artikel etwas umschreiben, was auch der Grund ist weshalb ich ihn nicht sofort geändert habe.

--[[Benutzer:Lyr|Lyr]] 01:32, 7. Jul 2006 (CEST)

Also ich weiß (glaube es jedenfalls) dass Fragmente auch Tiefeninfos besitzen. Das mit dem Rasterizer stimmt auch. Ich denke also, dass beide Aussagen stimmen.

--[[Benutzer:Flash|Flash]] 19:38, 10. Jul 2006 (CEST)

Naja, für die Fragment-Pipeline brauch ich auch Tiefen-Infos, die des neuen Fragmentes. Also für mich handelt es sich um ein Fragment auf dem Weg vom Rasterizer bis zu dem Zeitpunkt wo es im Framebuffer drinnen steht. Danach ist es für mich ein Pixel (ggf. mit Tiefeninfos, Alpha- und Stencil-Wert, aber dennoch nur ein Pixel). Und in diesem Artikel wäre nach meiner Auffassung zur Zeit der Begriff Fragment mit Pixel vertauscht worden.

Das englische Wikipedia scheint meine Auffassung zu teilen, wobei deren Artikel auch erst seit kurzem besteht.

In der OGL-Spezifikation unter "4. Per-Fragment Operations and the Framebuffer" (Version 1.2.1 und 1.3, wird sich aber wohl kaum geändert haben) am Anfang werden auch ein paar Andeutungen in die Richtung gemacht, im Sinne von wenn was im Frame Buffer drinnen ist, dann ist es ein Pixel. Vor allem durch den Satz unter 4.1: "A fragment produced by rasterization with window coordinates of (xw;yw) modifies the pixel in the framebuffer at that location based on a number of parameters and conditions." würde ich schon fast meine Hand dafür ins Feuer legen ... aber nur fast :-).

--[[Benutzer:Lyr|Lyr]] 00:52, 11. Jul 2006 (CEST)

Tiefentest

2006-07-07T00:06:37Z

Lyr: Tiefentest = gut und nicht böse auf heutiger Hardware

Bei der Berechnung eines [[Fragment]]es, muss OpenGL feststellen können, welche Teile der Grafik im Vordergrund stehen und welche Objekte ganz oder teilweise durch andere Objekte verdeckt werden.

== Funktionsweise ==
Für den Tiefentest existiert der [[Tiefenpuffer]]. Dieser ist genauso gross wie der Framebuffer. Für jeden Pixel auf dem Bildschirm gibt es dann also einen weiteren Wert - den Eintrag im Tiefenpuffer.

Im ersten Schritt wird der gesamte Tiefenpuffer auf den größtmöglichen Wert initialisiert (also die maximale Distanz, siehe [[glClear]] und [[glClearDepth]]).
Sobald dann ein Objekt gerendert wird, wird für jeden Pixel überprüft, ob der Tiefenwert des Pixels dieses Objekts kleiner ist als der Wert im Tiefenpuffer. Ist dies der Fall, wird dieses Pixel in den Framebuffer gezeichnet und der Tiefepuffer aktualisiert, ansonsten wird es verworfen. Der Test kann mittels [[glDepthFunc]] auch abgeändert werden. Zum Beispiel kann man dafür sorgen, dass auch gleich große Tiefenwerte akzeptiert werden.

Der Tiefentest findet verhältnismäßig früh in der [[Feste_Funktionspipeline#Fragment_Pipeline|Fragment-Pipeline]] statt, wodurch er sehr effizient nicht benötigte Fragmente ausschließen kann. Wenn Objekte tiefensortiert (in diesem Fall von vorne nach hinten) gezeichnet werden, ist der Tiefentest sehr gut geeignet um sehr früh nicht benötigte Fragmente zu verwerfen um so die [[Füllrate]] zu schonen.

== Transparenz und Tiefentest ==
Sobald Transparenz verwendet wird, kann der Tiefentest zumindest für diese Teile nicht mehr benutzt werden. Dies würde zu Fehlern führen, da das transparente Fragment ggfs. das durchscheinende, jedoch erst später an die Grafik-Pipeline gesendete und somit vom Tiefentest verworfene Fragment dahinter völlig verbirgt. Wenn man Transparente Fragmente nicht in den Tiefenbuffer schreibt, so können diese Fragmente von anderen, eigentlich weiter hinten liegenden, Fragmenten komplett überschrieben werden. 
Aus diesem Grund sollten Transparente Objekte nach allen anderen Objekten an OpenGL geschickt werden und diese möglichst von hinten nach vorne sortiert sein. Das Sortieren kann durch einen Alpha Wert im [[Framebuffer]] umgangen werden, jedoch ist dieser nur selten in Hardware vorhanden, wodurch in den weit langsameren Softwaremodus gewechselt wird.

Rasterisierung

2006-07-06T23:44:52Z

Lyr: Vor allem "vorletzter Schritt der OGL-Pipeline" ist etwas fragwürdig ...

Bei der Rasterisierung werden aus den bisher gesammelten geometrischen Daten, die in den [[Viewport]] gemappt wurden, die [[Fragment]]e generiert, welche dann alle für eine Bildschirmkoordinate benötigten Daten beinhalten.

Danach werden noch per-Fragment Operationen ([[Blending]], [[Feste_Funktionspipeline#Alpha_Test|Alpha Test]], [[Feste_Funktionspipeline#Stencil_Test|Stencil Test]], etc.) durchgeführt, bevor aus dem Fragment dann ein [[Pixel]] im [[Farbpuffer]] wird.

Diskussion:Fragment

2006-07-06T23:32:19Z

Lyr:

Normale

2006-07-06T23:18:26Z

Lyr: /* Wie berechne ich Normalen? */ <a,b> wird sehr sehr häufig für Skalarprodukt verwendet, sollte also nicht für Kreuzprodukt verwendet werden, wäre nur verwirrend.

= Normalen =

== Was ist das? ==
Eine '''Normale''' ist ein Vektor, der Senkrecht auf eine Fläche steht.

== Wozu brauch ich Normalen? ==
'''Normalen''' haben in OpenGL zwei zentrale Aufgaben.

# Sie zeigen welche Flächenseite die Vorderseite ist (anhand des Vorzeichens).
# Sie bestimmen wie Licht von der Fläche reflektiert wird.

== Wie berechne ich Normalen? ==
'''Normalen''' sind Flächennormalen. Das heißt, sie stehen senkrecht auf einer Fläche. 

'''Welche Fläche?'''

Eine beliebige...

Ersteinmal eine kurze Zusammenfassung. 
* Flächen bestehen aus Polygonen.
* Polygone bestehen aus n Dreiecken.
* Jedes Dreieck ist definiert durch seine 3 Eckpunkte.
* 3 Punkte liegen immer in einer Ebene

Wenn man nun die Normale eines Dreiecks berechnen will geht man folgenermaßen vor:
# Einen Eckpunkt als Bezugspunkt (P0) wählen.
# Die beiden Vektoren v1 = P1-P0 und v2 = P2-P0 bestimmen.
# Diese beiden Kreuzmultiplizieren v1 X v2. (steht in jedem Tafelwerk unter Kreuzprodukt)
# Das Ergebnis hat schonmal die richtige Richtung. (Für OpenGl reicht das.)

=== Normalisieren ===
Eine Normale heißt aber nur deshalb Normale, weil sie normiert ist. Das heißt sie ist 1 Längeneinheit lang. Wenn man einen Vektor normieren will dividiert man einfach den Vektor durch seine Länge.
Allgemein:
1/sqrt(x^2+y^2+z^2) * (x,y,z)

Beispiel eines normierten Vektors:

(1) normieren 1 (1)
(1) ----------> --- * (1)
(0) sqrt(2) (0)

Das Ergebnis ist die Normale des Dreiecks und damit auch der gesamten Ebene in der das Dreieck liegt.

Mit [[glNormal]] hat man in OpenGL explizit die Möglichkeit einer Fläche eine '''Normale''' zu zuweisen. Diese muss nicht senkrecht (wie eine echte Normale) auf dieser Fläche stehen. Damit hat man die Möglichkeit, die Beleuchtung von Flächen gezielt zu manipulieren.
 

''GL_NORMALIZE'' 
In OpenGL gibt es weiterhin die Möglichkeit die Normalen automatisch normalisieren zu lassen. Dazu muss mittels glEnable(GL_NORMALIZE) das Normalisieren eingeschaltet werden. Alle darauffolgenden Aufrufe von glNormal setzen die aktuelle Normale automatisch normiert. Abgeschaltet werden kann dies natürlich wieder durch glDisable(GL_NORMALIZE).

== Siehe auch ==
[[glNormal]]

Bounding Volume

2006-07-06T23:09:05Z

Lyr: /* Tradeoffs */ "möglichst dieselbe Füllrate" ist doch etwas stark übertrieben.

Bei dem '''Bounding Volume''' handelt es sich um die geschlossene Hülle eines Objektes.
Genauer gesagt ist ein Bounding Volume ein (möglichst einfaches) geometrisches Objekt, das ein anderes 3D-Objekt vollständig umschliesst.

==Anwendung==

Die zwei wichtigsten Techniken bei denen Bounding Volumes eingesetzt werden, sind das [[Occlusion Culling]], bei dem bestimmt werden muss, ob ein Objekt gezeichnet werden muss oder nicht, und beim [[Collision Detection]], wo bestimmt wird, ob zwei Objekte kollidieren oder nicht.

==Tradeoffs==
Es gibt zwei Kriterien, die bei der Erstellung eines Bounding Volumes berücksichtigt werden müssen.

Zuerst einmal sollte es das zu umschliessende Objekt so gut wie möglich approximieren.
Für [[Occlusion Culling]] ist es z.B. notwendig, dass das Bounding Volume möglichst exakt die Geometrie des Objektes widergibt.
Bei [[Collision Detection]] möchte man, dass die physikalischen Eigenschaften des Objektes durch das Bounding Volume so gut wie möglich approximiert werden.

Auf der anderen Seite sollte das Bounding Volume aber auch so einfach wie möglich konstruiert sein, denn ein Bounding Volume ist nur zweckmässig, wenn das zu umschliessende 3D-Objekt um ein Vielfaches komplexer ist.

==Arten==
Die am häufigste auftretenden Arten von Bounding Volumes sind die [[Bounding Box]], die [[Bounding Sphere]] und der [[Bounding Cylinder]].

Ein spezielles Bounding Volume ist die [[konvexe Hülle]] eines Objektes.
Diese approximiert ein 3D-Objekt zwar am besten, ist in der Praxis jedoch eher seltener im Einsatz.

[[Kategorie:Technik_oder_Algorithmus]]

Vertexlimitiert

2006-07-06T22:59:37Z

Lyr: - Beleuchtung. OGL-Licht wird üblicherweise per Vertex berechnet => Vertexlimitierung wird verstärkt.

Von einem "vertexlimitiertem" Szenario wird dann gesprochen, wenn das Rendern einer 3D-Szene durch den maximal möglichen Vertexdurchsatz einer Grafikkarte limitiert ist. D.h. dass in der Szene mehr Eckpunkte verwendet werden als die Grafikkarte verkraften kann.
Da aber selbst moderne Consumergrafikkarten '''mehrere hundert Millionen Eckpunkte pro Sekunde''' über den Bus schieben bzw. darstellen können (nicht zuletzt dank mehrerer Vertexprozessoren, z.B. 6 bei der neusten Radeon-Generation), wird man '''heutzutage kaum eine Anwendung finden die vertexlimitiert ist'''.

I.d.R. sind moderne Grafikkarten bzw. 3D-Anwendungen entweder durch [[Füllrate]] oder [[Shaderlimitiert|Shadergeschwindigkeit]] limitiert. Sollte dennoch ein Szenario der Vertexlimitierung (z.B. auf alter Hardware, oder Anwendungen die komplexe Geometrie ohne Texturen oder ohne Fragment-Shader rendern) auftreten, empfiehlt es sich die Szenerie durch '''Sichtbarkeitsprüfungen''' mittels [[Techniken_und_Algorithmen#Raumunterteilungstechniken|Raumunterteilung]] oder [[LOD|Level-Of-Detail]] zur Laufzeit an die Hardware anzupassen.

Benchmark

2006-07-05T22:48:33Z

Lyr:

Ein Benchmark ist ein Referenzwert für Messungen eines Systems. Ein System (im weiteren auf Computer reduziert) ist ein aus mehreren Einzelteilen bestehendes Gefüge, welches nicht nur die Eigenschaften der Einzelteile (RAM-Größe, [[Füllrate]], [[Bandbreitenlimitiert|Bandbreite]], Festplattengeschwindigkeit, ...) besitzt, sondern auch auftauchende Eigenschaften ([[Füllrate]]nlimitierung, Seitenflattern, ...) aufweist. Diese auftauchenden Eigenschaften können nicht über die Informationen der einzelnen Systemkomponenten bestimmt werden, sondern sind durch möglichst realitätsnahe Simulationen zu testen.

Üblicherweise handelt es sich bei einem Benchmark um eine Simulation von ein oder mehreren Applikationen die häufig auch auf unterschiedliche Eigenschaften des Computers eingehen. Beispielsweise könnte ein Benchmark für Computerspieler folgende Testprogramme enthalten:
*primär [[Füllrate]]nlimitierte (Landschaft, [[Schatten Volumen]], ...)
*primär [[Vertexlimitiert]]e (viele Lichter, hohe [[Vertex]]anzahl, lange [[Vertex]] [[Shader]], ...)
*primär [[Bandbreitenlimitiert]]e
*starker Festplattengebrauch (Nachladen während der Laufzeit nötig)
*viel CPU-Aufwand (Für KI-Berechnungen oder auch Sichtbarkeitsberechnungen und ähnliches)
Für jeden dieser Tests werden Punkte vergeben (Beispielsweise die durchschnittlichen Frames / Sekunde). Am Ende werden die Punkte der einzelnen Tests (gegebenenfalls mit einer bestimmten Gewichtung) in einen Endwert umgerechnet. Einge Möglichkeiten hierfür wären beispielsweise:
*Addition
*Arithmetisches Mittel
*Geometrisches Mittel
*Harmonisches Mittel
Dieser Endwert kann nun verwendet werden um 2 Computer (in Sicht auf ihre Performance) zu vergleichen. Im Idealfall kann solch ein Benchmark auch aufschluss über die Schwachstellen eines Computers liefern und somit als Endergebnis die Komponente aufzeigen die verbesserungsbedürftig ist.

Ein auf ein spezielles Gebiet zugeschnittener Benchmark ist eine gute Möglichkeit um 2 Computer miteinander zu vergleichen, jedoch sollte auch das Ergebnis eines Benchmarks mit Vorsicht genossen werden. Es handelt sich zum einen immer noch um einen simulierten Betrieb, und zum anderen werden häufig auch einzelne Komponenten gar nicht getestet (beispielsweise bei Benchmarks für Computerspiele findet man eher selten einen Test des Internetanschlusses).

Hintergrundwissen

2006-07-05T22:47:37Z

Lyr: /* Sonstiges */ +Bandbreitenlimitiert

== Was hier hinein gehört ==

In diese Kategorie kommt alles rein was zum Verständnis im Bereich OpenGL/3D-Programmierung nützlich sein könnte. Also u.a. welche Puffer es unter OpenGL gibt, und für was die gut sind.

Auch hier sollte man möglichst aufspalten und dann eine Überschrift setzen. So macht man das Auffinden bestimmter Dinge leichter und auch die Verlinkung darauf ist oft etwas das man in anderen Dokumenten benötigt.

P.S. : Ob hier Deutsche Begriffe oder Anglizismen genutzt werden ist jedem selbst überlassen. Ich persönlich bevorzuge ersteres.

== Begriffserklärungen ==
In diesem Teil findet ihr Erklärungen zu begriffen, die ihr ständig im Zusammenhang mit OpenGL höhrt. Wenn ihr etwas nicht kennt, könnt ihr hier nachsehen, ob der Begriff bereits erklärt wurde.

=== Grundlagen ===
: [[Funktions Anhang|Aufbau von OpenGL Funktionen]]
: [[Bounding Volume]] ([[Bounding Box]])
: [[Clipping Plane]] {{excIcon}} (Schnittebenen)
: [[Frustum]]
: [[Matrix|Matrix / Matrizen]]
: [[OpenGL Name|Namen in OpenGL]]
: [[Normalen]]
: [[Primitive]]
: [[Texel]] {{icpIcon}}

=== Bildentstehung ===
: [[Dithering]] {{icpIcon}}
: [[Fragment| Fragmente]]
: [[Pixel]]
: [[Rasterisierung]]
: [[Tiefentest]]

=== Puffer ===
: [[Akkumulationspuffer]] (Accumulationbuffer)
: [[Doppelpufferung]] (Doublebuffering)
: [[Farbpuffer]] (Colorbuffer)
: [[Feedbackpuffer]]
: [[Framebuffer]]
: [[Logischer Puffer]]
: [[Schablonenpuffer]] (Stencilbuffer)
: [[Selektionspuffer]]
: [[Tiefenpuffer]] (Depthbuffer)

=== Texturen ===
: [[Decals]]
: [[MipMaps]]
: [[Register Combiner]]
: [[Texel Berechnung]]
: [[Texturen]]

=== Textureneffekte ===
: [[Animierte Textur]]en
: [[Bumpmapping]] (Simulation rauher Oberflächen)
: [[Displacementmapping]] (Änderung der Oberflächengeometrie)
: [[Detailmapping]] (Erhöhung des Texturdetailgrades)
: [[Environment Mapping]] (Umgebungsspiegelung)
:: [[Cubemap]]ping {{icpIcon}}
:: [[Spheremap]]ping {{icpIcon}}
: [[Multitexturing]]
: [[Texture Stage]]

=== Effekte ===
: [[Antialiasing]] (Kantenglättung)
: [[Blenden]] (Blending)
: [[Jittering]] (Verwischen)
: [[Nebel]] (Fogging)
: [[Transparenz]] (durchsichtige Objekte)

=== Optimierungen ===
: [[Backfaceculling]]
: [[Displaylisten]]
: [[Frustum Culling]]
: [[Triangulation]]
: [[VBO]] (Vertex Buffer Objects)

=== Weiterführendes ===
: [[Beleuchtung]]
: [[Billboard]]s
:: [[sphärisches Billboard]] {{icpIcon}}
:: [[zylindrisches Billboard]] {{icpIcon}}
: [[Convolution]]
: [[NURBS]]
: [[Picking]]
: [[Point Sprite]]
: [[Quadrik]]en
: [[Selektion]]
: [[Sprite]]s
: [[Tesselierung]]

=== Fehler/ Nebeneffekte ===
: [[Aliasing]] (Treppenbildung und Ähnliches)
: [[Popping]] (Plötzliches Auftauchen von Elementen. Z.B. bekannt bei [[LOD]])
: [[ZFighting]] (Flimmernde Polygone und Kanten)

=== Render-Pipeline ===
: [[Feste Funktionspipeline]] {{icpIcon}}
: [[GLSlang]]
: [[GLSL]]
: [[Shader]] (allgemein)
:: [[Fragmentshader]]
:: [[Vertexshader]]

=== Bibliotheken ===
: [[DGLSDK]]
: [[OpenAL]]
: [[SDL]]

=== Sonstiges ===
: [[Benchmark]]
: [[Callback]]
: [[Füllrate]]
: [[Renderkontext]]
: [[Scanlinerenderer]]
: [[Timebased Movement]]
: [[Vertexlimitiert]]
: [[Shaderlimitiert]]
: [[Bandbreitenlimitiert]]

=== Bücher zum Thema ... ===
: ... OpenGL: [[RedBook]]
: ... OpenGL: [[BlueBook]]
: ... OpenGL: [[PurpleBook]]
: ... OpenGL: [[OrangeBook]]
: ... OpenGL: [http://www.starstonesoftware.com/OpenGL/ OpenGL Superbible]

== Checklisten ==
In diesem Teil findet ihr Checklisten die ihr durcharbeiten solltet, wenn ihr Fehler im Code habt, bzw. wenn eure Ausgabe nicht so aussieht wie sie es söllte.

:[[Checkliste Blending]]
:[[Checkliste Positionierung]]
:[[Checkliste Selektion]]
:[[Checkliste Shader]]
:[[Checkliste Texturierung]]

Bandbreitenlimitiert

2006-07-05T22:46:24Z

Lyr:

Auch in Bezug auf Grafikkarten kann die Bandbreite, also die maximale Datenmenge welche pro Zeiteinheit zur Grafikkarte gesendet werden kann, der Ausschlaggebende Faktor für die Framerate sein. Wenn eine Applikation Bandbreitenlimitiert ist, so bedeutet dies, dass die Applikation zu viele Daten über den PCI oder AGP-Bus an die Grafikkarte sendet oder von ihr erhalten will.

Eine Grafikkarte ist sehr stark darauf ausgelegt, dass sie ausschließlich Daten erhält, wodurch die CPU nur selten auf die Grafikkarte warten muss (sie sollten möglichst parallel arbeiten). Hingegen dazu ist Feedback von der Grafikkarte nur selten gewünscht, wodurch Anfragen an die Grafikkarte (welcher Art auch immer) enorme Performance Einbusen nach sich ziehen können. Und obwohl derartige Probleme eher weniger mit der Bandbreite des Busses zu tun haben, werden sie häufig auch in diese Problemkategorie eingereiht. Aufgrund dessen muss man sehr stark unterscheiden zwischen Daten die an die Grafikkarte gesendet werden und denen die von der CPU verlangt werden. Man fasst also häufig Synchronisations-Probleme und Bandbreiten-Probleme zusammen.

Häufige Ursachen für Bandbreitenlimitierung:
* Der Speicher der Grafikkarte muss teilweise auf den Hauptspeicher ausgelagert werden.
* Zu viele Texturen werden erstellt oder verändert (beispielsweise mittels [[glTexSubImage]])
* Zu häufig (bzw. an zu viel verschiedenen Stellen) werden Daten von der Grafikkarte verlangt (Feedback-Buffer, [[glReadPixels]], ...)
* Zu viele Renderdaten werden an die Grafikkarte gesendet. Dies resultiert jedoch üblicherweise in einer [[Vertexlimitiert|Vertexlimitierung]] wenn die drei anderen Aspekte nicht zutreffen.

Die Bandbreite kann weniger beansprucht werden durch:
* Weniger Texturen die häufig erstellt oder verändert werden.
* [[glBindTexture]] nur dann wenn nötig (nach Texturen sortiert zeichnen) sofern die Texturen im Hauptspeicher ausgelagert werden.
* Verwendung von Display Listen oder Vertex Buffer Objects, sofern der Grafikkartenspeicher nicht bereits überfüllt ist.
* Weniger Anfragen an die Grafikkarte.
* Verwendung von Synchronisations-Extensions wie GL_NV_fence wenn häufig Daten von der Grafikkarte angefordert werden.
* Weniger Geometrie-Daten (zB. durch [[glMap2]], Level of Detail, Frustum Culling, ... ).

Bandbreitenlimitiert

2006-07-05T22:40:30Z

Lyr:

Kategorie Diskussion:Exzellent

2006-07-03T22:58:13Z

Lyr: Kommentar: Convolution Filter

=Vorraussetzungen für Exzellente Artikel=
Hier könnt ihr Artikel vorschlagen welche ihr als "exzellenten Artikel" einstufen würdet.

Folgende Punkte '''müssen''' erfüllt sein:
* Kein Sackgassenartikel - Artikel muss auf andere Artikel direkt (nicht über Code) verlinken
* Kein Plain Text - Artikel muss eine einheitliche Formatierung aufweisen
* Bilder - Artikel muss mindestens ein Bild/Grafik besitzen
* Vollständig - Der Artikel muss das Thema umfassend behandeln
* Kein Tutorial - Der Artikel darf nicht der [[:Kategorie:Tutorial|Kategorie Tutorial]] angehören.

Damit ein Artikel als '''exezellent''' eingestuft wird müssen:
* 5 Wiki-User der Wahl zustimmen darunter mindestens ein Moderator,
* keine Gegenstimmen bestehen,
* die Vorraussetzungen von oben gelten.

 
=Kandidatenliste=
Um einen Artikel zur Kandidatenliste hinzuzufügen bitte den Nachfolgenden Code vor dem Ende ("<nowiki>|}</nowiki>") der Tabelle einfügen:

|<nowiki>[[Artikelname]]</nowiki>
|
|
|
|-

Um eine Stimme abzugeben, kopiert ihr bitte den Wiki-Code "<nowiki>--~~~~</nowiki>" in die entsprechende Spalte. Das Wiki generiert daraus eure Unterschrift (Signatur).

Falls ihr eine Gegenstimme abgebt, muss eine Begründung dazu gegeben werden.

----
 
<div align="center">
{|{{Prettytable_B1}}
!width="15%"|Vorgeschlagener Artikel
!width="20%"|Beführworter
!width="20%"|Gegner
!width="45%"|Begründung für Gegenstimme / Diskussion
|-
|[[Skybox]]
|
|
| Wenn hier noch jemand ein Codebeispiel liefern könnte wäre der Artikel auch Excellent. So ist er etwas Kurz. (Kriterium der Vollständigkeit ;))
|-
|[[glBegin]]
| --[[Benutzer:Lyr|Lyr]] 17:14, 7. Apr 2006 (CEST),
--[[Benutzer:Flash|Flash]] 11:53, 2. Mai 2006 (CEST),
--[[Benutzer:I0n0s|I0n0s]] 01:47, 3. Mai 2006 (CEST)
|
| Dieser Artikel wäre sicherlich auch ein Kandidat. Was mich bei ihm noch etwas zögerlich stimmt ist die Beschreibung. Diese ist realtiv weit weg vom Orginal. Das ist nicht sodnerlich schlimm, nur muss halt sichergestellt werden, dass alle Infos der orginal Spezifikation enthalten sind.

Scheint mir (zumindest was OGL 1.1 betrifft) vollständ und sieht auch ganz nett aus.

Habe ihn nochmal gecheckt. Ist soweit ich das sehe vollständig.
|-
|[[DelphiGL]]
| --[[Benutzer:Luketheduke|luketheduke]] 12:06, 2. Apr 2006 (CEST),
--[[Benutzer:I0n0s|I0n0s]] 01:47, 3. Mai 2006 (CEST)
| --[[Benutzer:Lyr|Lyr]] 07:02, 15. Jun 2006 (CEST),
--[[Benutzer:Flash|Flash]] 12:12, 16. Jun 2006 (CEST),
--[[Benutzer:BenBE|BenBE]] 18:12, 1. Jul 2006 (CEST)
| Phobeus hat die Anfänge ergänzt -> jetzt bin ich auch ein Fan. --[[Benutzer:Flash|Flash]] 19:37, 10. Apr 2006 (CEST)
Gegenstimme: obwohl dieser Artikel informell aufgebaut ist, fällt er für mich in die Kategorie Werbung oder zumindest in die Kategorie: Beschreibung was hier zu finden ist, bzw. wer dies zustande gebracht hat. In meinen Augen sollte ein Beitrag darüber was auf einer Seite gemacht wird - oder wer diese verfasst hat - ''niemals'' hervorgehoben werden. Entweder die Seite ist so gut dass sie ohne entsprechende Hervorhebung ihrer Leistungen auskommt, oder eine derartige Hervorhebung (auf der Seite selbst) kann auch nichts daran ändern. Im Endeffekt: als Information gut gebrauchbar, aber lesenswert ... nur für die die es interessiert, also für die die dieses Wiki anpsrechend finden und diejenigen informieren sich darüber wer dies geschaffen hat ... oder auch nicht. Für alle anderen (wenn ich hier von meiner Perspektive sprechen darf) klingt ein derartiger "lesenswerter" Artikel wie Heuchelei. Um den (hier vielleicht zu häufig verwendeten) Vergleich zu Wikipedia zu ziehen: damals als ein solcher Artikel noch einer der besten war hätte sich keiner dafür interessiert. Und jetzt wo die Entstehungsgeschichte von Wikipedia vielleicht eine Erwähnung hier und da Wert wäre gibt es in Wikipedia bereits viele viele Artikel die bei weitem lesenswerter sind als dessen Entstehungsgeschichte.

--[[Benutzer:Lyr|Lyr]] 07:02, 15. Jun 2006 (CEST)

Ich stimme Lyr zu. Wir sollten uns bei den excellenten/lesenswerten Artikeln auf unser Zentrales Thema Grafikprogrammierung konzentrieren. Der DelphiGL Artikel ist sicherlich ein Schätzchen, wir den normalen Leser aber bestimmt wenig interessieren.

--[[Benutzer:Flash|Flash]] 12:12, 16. Jun 2006 (CEST)

Kann mich Flash und Lyr in Bezug auf den [[DelphiGL]]-Artikel nur anschließen. Außerdem würde ich in Bezug auf die Gestaltung 2 Dinge bemängeln, die als zwingende Vorgaben zu sehen sind:
#Als Illustration werte ich keinesfalls das zeigen eines Graphen, der die Mitgliederzahl in Abhängigkeit von der Zeit enthält, oder Tabellen, die deren erste Ableitung enthalten. Außerdem ist der Verweis auf die Mitgliederkarte zwar sinnvoll, ist aber auch etwas "lieblos" im Artikel reingeschmissen. Der Artikel muss also in Hinblick auf die äußere (gleichmäßige) Formatierung\Gestaltung auf jeden Fall überarbeitet werden.
#Zweitens zweifle ich stark die Vollständigkeit dieses Artikels an. Es gibt nämlich nicht nur die frühsten Anfänge und ein Jetzt, sondern auch (2-3 Jahre) dazwischen, die mir in diesem Artikel teilweise (bis ganz) fehlen. Auch ist der unter [[DelphiGL#Historie_im_Überblick]] gezeigte Zeitgraph an relativ vielen Stellen relativ weiß, was IMHO nicht für dessen Vollständigkeit spricht. Weiterhin fehlt in Bezug auf die Aprilscherze, die angeführt werden, die Informationen für die Jahre 2003 und 2004.
Insgesamt gefällt mir der Artikel also aus folgenden Gründen nicht:
#Aufmachung und Layout-Gestaltung
#Präsentation\Gliederung der Informationen
#Vollständigkeit der dargebrachten informationen
--[[Benutzer:BenBE|BenBE]] 18:12, 1. Jul 2006 (CEST)

|-
| [[Convolution-Filter]]
| --[[Benutzer:I0n0s|I0n0s]] 12:49, 15. Jun 2006 (CEST)
--[[Benutzer:Flash|Flash]] 15:06, 28. Jun 2006 (CEST)
|
|Ohne mich jetzt explizit dagegen auszuprechen, möchte ich doch anmerken, dass man bei diesem Artikel noch einige Feinheiten wie (vor allem) eine etwas nähere Erklärung zum Gaussian-Blur einfügen könnte, und auch Informationen und/oder Verweise für Bias bzw. Skalierung der Werte etwas fehlen. Gaussian-Blur ist nun mal keine einfache Matrix die man hin "schmeisst" und das wars und Bias und Skalierung sollte der Vollständigkeit halber drinnen sein, somal es (meines Wissens nach) sogar von OpenGL unterstützt wird.

Also bevor das nicht drinnen ist gibts von meiner Seite aus keine Pluspunkte :-).

--[[Benutzer:Lyr|Lyr]] 00:58, 4. Jul 2006 (CEST)
|-
| [[glTexParameter]]
| --[[Benutzer:Flash|Flash]] 15:06, 28. Jun 2006 (CEST)
|
|
|}
</div>

 
 
 
 

== Auswahlkriterien ==

Ich finde die Asuwahlkriterien etwas strange. Schließlich sind Tutorials auch Artikel und in den meisten Fällen noch dazu ziemlich gute. Warum sollten diese also ausgeschlossen werden? Vermitteln ja schließlich meist recht anschaulich viel Information. Also exakt das, was nen guten Artikel ausmacht.
--[[Benutzer:Frase|Frase]] 18:48, 18. Mär 2006 (CET)

Tutorials sind einzelarbeiten die von einer Person gemacht wurden und die eigentlich auch nur von dieser zu Verantworten/Verbessern sind. Die Auszeichnung soll gerade dafür sorgen die "graue Maus" Artikel aufzuwerten. Das unsere Tutorials alle Exzellent sind steht außer Frage. Die Auszeichnung heißt aber nicht um sonst "Exzellente Artikel" und nicht "Exzellente Tutorials". Außerdem soll die Auzeichnung erreichen, dass die Nutzer einfach mal ins Wiki reinlesen. Tutorials sind in sich geschlossen und verlinken kaum auf andere Artikel. Sie behandeln ein Thema, und das ist gut so.
--[[Benutzer:Flash|Flash]] 01:11, 19. Mär 2006 (CET)

Und es kann die Leute animieren die Artikel den Kritierie anzupassen bzw. eigene Artikel einzustellen.
So hat es zumindest bei mir funktioniert. Ich habe jetzt sogar Bilder! :lol:

--[[Benutzer:I0n0s|I0n0s]] 04:35, 19. Mär 2006 (CET)

O-Notation

2006-06-30T15:54:27Z

Lyr: Noch eine kleine Anmerkung

Die O-Notation beschreibt die Qualität eines Algorithmus (nicht jedoch die Qualität der Implementierung!). Meistens wird die Laufzeit betrachtet, jedoch kann die O-Notation beispielsweise auch für den Speicherbedarf verwendet werden.

Die O-Notation besagt (sehr grob ausgedrückt): Die maximale Laufzeit für n Elemente übersteigt nicht die durch Faktor * O( f(n) ) angegebene Funktion.

Es handelt sich also um eine stark vereinfachte Berechnung des Laufzeitverhalten. Es fließen dabei nicht mit ein:
*Initialisierungen und Vorberechnungen (die O-Notation ist für hohe Wertebereiche ausgelegt)
*kleine Nebenberechnungen (da sie bei hohen Wertebereichen keine Rolle mehr spielen)
*Den Faktor (welcher stark von der Implementierung und der Hardware abhängen kann)

'''Dadurch gilt also:'''
*O( n*n + 10*n + 100 ) = O( n*n ): Initialisierungen und kleine Nebenberechnungen weg lassen
*O( 3*n ) = O( n ): Faktoren weg lassen
*O( ld( n ) ) = O( log( n ) ): Faktoren weg lassen ( ld( n ) = log( n ) / log( 2 ) )
*O( n ) darf als O( n*n ) geschrieben werden: n übersteigt ab einem gewissen Wert X niemals n*n
*O( n*n ) darf nicht als O( n ) geschrieben werden: n*n übersteigt bei hohen Wertebereichen n => nicht gültig

'''Typische Algorithmen und ihre Laufzeiten:'''
*O( 1 ): Zugriff auf ein Element in einem Array
*O( log(n) ): Element suchen in einer (ausgeglichenen) Baumstruktur
*O( n ): Element suchen in einer Liste oder einem unsortierten Array
*O( n*log(n) ): Gute Sortieralgorithmen wie zB Heap Sort
*O( n*n ): Schlechte Sortieralgorithmen wie zB Bubblesort

'''Wozu sollte die O-Notation verwendet werden:'''
*Für einen groben Vergleich von Algorithmen
*Für eine grobe Einteilung der Zeitkomplexität von Algorithmen
*Um besser einschätzen zu können für welche Wertebereiche ein Algorithmus geeignet ist
*Um besser einschätzen zu können wie stark n steigen darf mit der Hardware in einem Jahr (welche etwa doppelt so schnell ist)

'''Wo sollte die O-Notation mit Vorsicht genossen werden:'''
*Genaue Bewertung eines Algorithmus (In der praktischen Anwendung laufen viele Algorithmen deutlich schneller als in der pessimistischen Theorie)
Beispiel: Quicksort hat eine maximale Laufzeit von O( n*n ), jedoch eine durchschnittliche Laufzeit von O( n*log(n) )

'''Formale Definition:''' 
Seien f(x) und g(x) 2 Funktionen, dann gilt:
f(x) = O( g(x) ) für x -> unendlich
wenn folgende Bediengung zutrifft:
Es gibt 2 Zahlen a und b so dass:
f(x) <= b * g(x) für alle x > a

'''Einschränkungen'''

Anzumerken sei noch, dass man bei der O-Notation üblicherweise weitere Annahmen trifft. So benötigt man zum Beispiel für das addieren von 2 Zahlen nicht eine Laufzeit von O(1) sondern O(n), wobei n die Anzahl der Bit dieser Zahlen ist. Dies wird jedoch üblicherweise vernachlässigt, da man sich meist mit Zahlen mit fixer Größe (heutzutage 32 oder 64 Bit) zufrieden gibt. Es spielt jedoch durchaus eine Rolle, wenn es beispielsweise um Mathematik-Bibliotheken mit beliebig großen Zahlen geht.

Der umgekehrte Fall kann jedoch eintreffen wenn man einen Algorithmus für parallele Rechner implementiert. In diesem Fall existiert häufig auch eine kleinere obere Schranke für einen Algorithmus.

Floyd Warshall

2006-06-30T15:42:37Z

Lyr: /* Kritik */ O-Notation-Links

==Eigenschaften==
Der Floy Warshall Algorithmus findet nicht nur den kürzesten Weg von einer Position zu einer anderen, sondern bestimmt alle kürzesten Wege von jedem Punkt zu jedem anderen.

Der Graph darf negative Kanten enthalten aber Vorraussetzung ist, dass '''keine negativen Kreise''' im Graph enthalten sind. (Kreise die negative Kosten verursachen.)

==Algorithmus==
Der Algorithmus basiert auf einer (Adjazenz-)Matrix. Die Knoten des Graphen werden als Index verwendet.
Der Zeilenindex stellt den Startknoten dar, der Spaltenindex den Zielknoten.

<pascal>
T[1..n][1..n] of integer; //n = Anzahl der Knoten

//Initialisierung
Matrix mit Maximalwert initialisieren.
Hauptdiagonale mit 0 initialisieren

for i := 1 to n do
for each Nachbar j von i do
T[i][j] = Kosten(i nach j);

//Eigentliches bestimmen der kürzesten Wege
for z := 1 to n do //z = zwischenknoten
for i := 1 to n do //i = startknoten
for j := 1 to n do //j = Zielknoten
if (T[i][z] + T[z][j]) < T[i][j]) then //"Wenn der Weg über den Zwischenknoten z besser ist
T[i][j] := T[i][z] + T[z][j]; // als der direkte, nimm diesen Weg."
</pascal>

Falls auf der Hauptdiagonale irgendwann ein Wert kleiner 0 steht hat man einen negativen Kreis gefunden. Dadurch ist nicht mehr sichergestellt, dass die Ergebnisse korrekt sind.

Am Ende des Algorithmus stehen in T[i][j] die minimalen Kosten um von i nach j zu kommen.
Steht in T[i][j] der Maximalwert (siehe Initialisierung) ist j von i aus nicht erreichbar.

==Kritik==
'''Vorteile:'''
*Der Algorithmus findet die minimalen Kosten von '''allen''' Wegen im Graph.
*Der Algorithmus ist deshalb besonders geeignet um die kürzesten Wege in statischen Netzwerken zu finden, da er nur einmal ausgeführt werden muss.

'''Nachteile:'''
*Der Algorithmus muss bei Änderungen des Netzwerks erneut aufgerufgen werden und berechnet dann alles neu.
*Der Algorithmus benötigt [[O-Notation|O]](n²) Speicherplatz.
*Mit einer '''Laufzeit von [[O-Notation|O]](n³)''' ist er nicht besonders schnell.

Interpolation

2006-06-17T17:15:01Z

Lyr: /* Normalvektoren */

Bei Interpolationsverfahren geht es darum, aus wenigen Werten beliebig viele Werte zu generieren. Da die gegebenen Werte - wo Interpolation nötig ist - meistens als Stichproben gesehen werden können, werden verschiedenste Verfahren benötigt um auch die nicht gegebenen Werte den Ansprüchen entsprechend zu berechnen. Die Ansprüche variieren hierbei etwas anhand der Geschwindigkeitsanforderungen, des Zahlenraumes und nicht zuletzt anhand der Art und Weise wie man interpolieren möchte.

=Polynom Interpolationen=
Wenn man N gegebene Werte hat, so kann man diese mit einem Polynom (N-1)ten Grades interpolieren. Eine Polynom Interpolationen besitzen die allgemeine Form:
I = (t^n)*Fn + (t^(n-1))*F(n-1) + ... + t*F1 + F0
Wobei:
t ... die Interpolationsposition im Wertebereich [0|1]
Fx ... ein konstanter Wert oder Faktor (oder allgemein ein m-Dimensionaler Vektor)
I ... das interpolierte Ergebnis, was ebenfalls ein einzelner Wert oder ein Vektor sein kann.
Durch die Vektor-Schreibweise sollte bereits klar sein, dass Polynom-Interpolationen für jede Dimension extrig berechnet werden, und somit auf beliebig viele Dimensionen erweiterbar sind.

== Lineare Interpolation ==
=== Allgemein ===
Die einfachste Form einer Polynom-Interpolation ist die lineare Interpolation. Hierbei sind nur 2 Werte gegeben, somit kann man diese Werte mit einem Polynom ersten Grades interpolieren. Dieses ist (wie unschwer zu erraten) eine Gerade der Form:
I = t*F1 + F0
Diese (eher ungewöhnliche) Form der Geradengleichung entspricht der oben angegebenen Polynom-Interpolation in beliebiger Dimension. Die Berechnung der Faktoren Px erfolgt hier für jede Dimension getrennt. Gegeben seien 2 m dimensionale Punkte (A1, A2, ..., A(m-1), Am) und (B1, B2, ..., B(m-1), Bm). Nun lässt sich für jede Dimension d ein einfaches Gleichungssystem aufstellen:
Ad = 0*F1d + F0d
Bd = 1*F1d + F0d
da wir mit einem Interpolationswert von 0 den ersten Punkt (A) erhalten wollen und einem Interpolationswert von 1 den zweiten Punkt (B) möchten. Dies umgeformt auf P1d und P0d ergibt:
F0d = Ad
F1d = Bd - Ad
Diesen Rechenschritt wiederholen wir für jede Dimension.

=== Rechenbeispiel ===
Wir wollen 2 Punkte im 3 dimensionalen Raum interpolieren:
A: (2|5|0)
B: (4|1|8)
Wir berechnen uns die Vektoren P1 und P0 wie oben angegeben, wobei x die erste und z die dritte Dimension dar stellen soll:
F0x = Ax = 2
F1x = Bx - Ax = 2
F0y = Ay = 5
F1y = By - Ay = -4
F0z = Az = 0
F1z = Bz - Az = 8
Somit erhalten wir die unsere Interpolationsgleichung:
I(x|y|z) = t * (2|-4|8) + (2|5|0)

Das Ergebnis sieht nun folgendermaßen aus:

[[Bild:InterpolationBsp1.png]]

''2 dimensionale Version des obigen Beispieles. Die gegebenen Punkte sind somit A(2|5) und B(4|1). Diese Punkte sind in rot dargestellt. Die Gerade beinhaltet alle Punkte für die gegebene Formel mit t im Wertebereich [0|1]''

== Polynome höheren Grades ==
=== Allgemein ===
Wie euch vielleicht schon bei der linearen Interpolation aufgefallen ist, ist eine Reihung der Punkte (vorher nur 2) erforderlich. Welcher PUnkt soll das Ergebnis mit t = 0 sein? Und welcher mit t=1? Wenn man mehr als 2 Punkte gegeben hat, so benötigt man zusätzlich noch die Informationen für welches t die beiden neuen Punkte gelten sollen. Meistens interpoliert man hier die Werte für t linear. Das heißt bei N gegebenen Punkten, soll der x-te Punkt für den t-Wert
t(Px) = x / (N-1) + 0
gegeben werden. Wobei:
t(Px) ... der t-Wert für den x-ten Punkt
Das (N-1) der Gleichung wird uns noch länger verfolgen, deshalb werden wir im weiteren Verlauf N-1 als n bezeichnen. Hier noch kurz die Anmerkung, dass man bei einem gegebenen Punkt natürlich keine Parameter benötigt sondern der Punkt immer gleich ist. Man kann sich dies (und alles darauffolgende) auch so vorstellen, dass wir den ersten gegebenen Punkt F0 als 0-Punkt annehmen und erst am "Ende" F0 addieren. Aus dieser Sichtweise heraus bekommen wir unser n = N-1.

Nun lässt sich wiederum das allgemeine (lineare) Gleichungssystem auffstellen:
P0 = t(P0)^n * Fn + t(P0)^(n-1) * F(n-1) + ... + t(P0) * F1 + F0
P1 = t(P1)^n * Fn + t(P1)^(n-1) * F(n-1) + ... + t(P1) * F1 + F0
...
Pn = t(Pn)^n * Fn + t(Pn)^(n-1) * F(n-1) + ... + t(Pn) * F1 + F0
Wobei:
Px ... der x-te Punkt
t(Px) ... der t-Wert für den x-ten Punkt
Fy ... der zu berechnende Faktor
Also ein Gleichungssystem mit n unbekannten und n (linear unabhängigen) Gleichungen, welches sich demnach eindeutig lösen lässt. Wobei dieses Gleichungssystem wiederum für jede Dimension extrig aufgestellt und berechnet werden muss! Da man (eindeutig lösbare) Gleichungssystem recht angenehm durch Matrizen-Mathematik lösen kann, empfiehlt sich auch folgende Schreibweise:
P = M * F
Wobei:
P ... ein N dimensionaler Vektor der die gegebenen Werte für den jeweiligen Punkt beinhaltet
M ... eine NxN Matrix welche die t(Px)^y beinhaltet
F ... ein N dimensionaler Vektor der die zu berechnenden Faktoren erhält
und N ... wie gehabt die Anzahl der gegebenen Punkte und n = N - 1

Dies kann man nun umformen in:
M^-1 * P = F
Wobei:
M^-1 ... die inverse von M ist

Dadurch erhält man alle Werte Fy die man benötigt und kann somit für ein gegebenes t wiederum in die allgemeine Form:
I = (t^n)*Fn + (t^(n-1))*F(n-1) + ... + t*F1 + F0
einsetzen.

=== Rechenbeispiel ===
Wir wollen über 4 Punkte eine Polynominterpolation im 2 dimensionalen Raum. Diese sind:
P0: (5|3)
P1: (1|4)
P2: (4|2)
P3: (1|2)
Wir legen nun zuerst wieder die t-Werte für die Punkte fest, und sagen:
P0 bei t=0
P1 bei t=1/3
P2 bei t=2/3
P3 bei t=1
Und berechnen uns nun die Matrix M mit diesen t-Werten:
| 0^3 0^2 0^1 1 |
M = | 0.33^3 0.33^2 0.33 1 |
| 0.66^3 0.66^2 0.66 1 |
| 1^3 1^2 1^1 1 |
Und berechnen uns nun die inverse M^-1:
| -4.5 13.5 -13.5 4.5 |
M^-1 = | 9 -22.5 18 -4.5 |
| -5.5 9 -4.5 1 |
| 1 0 0 0 |
Nun nehmen wir den P-Vektor der ersten Dimension:
Px = (5|1|4|1)
und multiplizieren ihn mit der Matrix wodurch wir
Fx = M^-1 * Px = (-58.5|90|35.5|5)
erhalten. Nun das selbe für die zweite Dimension:
Py = (3|4|2|2)
und wiederum
Fy = M^-1 * Py = (22.5|-36|12.5|3)

Somit ist unsere endgültige Formel für die Interpolation:
Ix = -58.5 * t^3 + 90 * t^2 - 35.5 * t + 5
Iy = 22.5 * t^3 - 36 * t^2 + 12.5 * t + 3

Das Ergebnis sieht nun folgendermaßen aus:

[[Bild:InterpolationBsp2.png]]

''Oben angegebenes Beispiel grafisch dargestellt. Die Punkte P0 bis P3 sind rot dargestellt. Die Kurve beinhaltet alle Punkte der gegebenen Funktionen für ( Ix , Iy ) mit t im Wertebereich [0|1].''

=Kurven mit gegebenen Tangenten=
Wir haben die oben gegebene Polynom-Gleichung für N Punkte. Wenn wir nun zusätzlich J Tangenten angeben möchten, so haben wir natürlich J zusätzliche Gleichungen und benötigen ein Polynom (N+K-1)ten Grades. Als erstes stellen wir wiederum eine derartige Polynom-Gleichung auf, jedoch mit dem Unterschied das wir dies gleich mit dem (N+J-1)ten Grad machen. Des weiteren müssen wir für jede Tangente Festlegen bei welchem t^x wir sie einbrigen möchten. Der Einfachheit halber wird hier die Reihung: zuerst die Punkte (also einem t^x mit höherem x) und danach die Tangenten (also einem t^x mit niedrigerem x als die Punkte bis hin zu x=0) verwendet. Daraus ergibt sich die allgemeine Form für die Punkte:
P0 = t(P0)^(n+J) * F(n+J) + t(P0)^(n+J-1) * F(n+J) + ... + t(P0)^(J+1) * F(J+1) + t(P0)^J * F(J) + t(P0)^(J-1) * F(J-1) + t(P0)^(J-2) * F(J-2) + ... + t(P0) * F1 + F0
P1 = t(P1)^(n+J) * F(n+J) + t(P1)^(n+J-1) * F(n+J) + ... + t(P1)^(J+1) * F(J+1) + t(P1)^J * F(J) + t(P1)^(J-1) * F(J-1) + t(P1)^(J-2) * F(J-2) + ... + t(P1) * F1 + F0
...
Pn = t(Pn)^(n+J) * F(n+J) + t(Pn)^(n+J-1) * F(n+J) + ... + t(Pn)^(J+1) * F(J+1) + t(Pn)^J * F(J) + t(Pn)^(J-1) * F(J-1) + t(Pn)^(J-2) * F(J-2) + ... + t(Pn) * F1 + F0
Wobei:
Px ... der x-te Punkt
t(Px) ... der t-Wert für den x-ten Punkt
F(n+J) bis F(J) ... der zu berechnende Faktor für den (N-1)ten Punkt
F(J-1) bis F(0) ... der zu berechnende Faktor für die J-te Tangente
Nun benötigen wir natürlich noch weitere Gleichungen für die Tangenten um das Gleichungssystem eindeutig lösbar zu machen. Eine Tangente K (hier wird bewusst K und nicht T gewählt) für den Xten Punkt lässt sich durch eine Ableitung nach t berechnen:
K(Px) = (n+J) * t(Px)^(n+J-1) * F(n+J) + (n+J-1) * t(Px)^(n+J-2) * F(n+J-1) + ... + (J+1) * t(Px)^(J) * F(J+1) + J * t(Px)^(J-1) * F(J) + (J-1) * t(Px)^(J-2) * F(J-1) + (J-2) * t(Px)^(J-3) * F(J-2) + ... + t(Px) * F2 + F1 + ( 0 * F0 )
Mit diesen Gleichungssystemen können wir wiederum eine Matrix formen, diese invertieren und los legen. Aber (meines Erachtens) erklärt sich dies am besten an einem Beispiel.

=== Hermite Kurven ===
Hermite Kurven sind Interpolationsfunktionen wo der Anfangs- und Endpunkt eine bestimmte Tangente aufweist. Üblicherweise werden Hermite Kurven zusätzlich noch auf 2 gegebene Punkte beschränkt, was wir hier der Einfachheit halber beibehalten wollen. Wir haben 2 Punkte, 2 Tangenten wodurch wir auf ein Polynom (N+J-1) = (2+2-1) = 3ten Grades kommen. Alse stellen wir eine Polynomgleichung für 2 gegebene Punkte auf, wobei der erste Punkt den Zeitpunkt 0 und der zweite Punkt den Zeitpunkt 1 erhält. Dadurch kommen wir auf zwei triviale Gleichungen:
P0 = 0 * F(3) + 0 * F(2) + 0 * F(1) + 1 * F(0)
P1 = 1 * F(3) + 1 * F(2) + 1 * F(1) + 1 * F(0)
Nun noch die Tangentengleichungen die sich aus der oben angegebenen K(Px) - Formel ergeben:
K0 = 0 * F(3) + 0 * F(2) + 1 * F(1) + 0 * F(0)
K1 = 3 * F(3) + 2 * F(2) + 1 * F(1) + 0 * F(0)
Dies ist unser lineares Gleichungssystem woraus wir wiederum unsere Matrix gewinnen:
| 0 0 0 1 |
M = | 1 1 1 1 |
| 0 0 1 0 |
| 3 2 1 0 |
Und natürlich die Formel:
W = M * F
Wobei:
W ... ein Vektor ist der die Werte P0, P1, K0, K1 (in dieser Reihenfolge) beinhaltet
M ... die oben gegebene Matrix
F ... der Vektor der die zu berechnenden Werte beinhaltet.
Diese Matrix invertiert ergibt:
| 2 -2 1 1 |
M^-1 = | -3 3 -2 -1 |
| 0 0 1 0 |
| 1 0 0 0 |
Somit können wir den F-Vektor berechnen durch
M^-1 * W = F
Wenn wir nun also für W die Werte (2,3,-1,1) hätten, wobei hier
2 ... der erste Punkt
3 ... der zweite Punkt
-1 ... die Tangente für den ersten Punkt
1 ... die Tangente für den zweiten Punkt
so ergeben sich daraus die Faktoren:
F = M^-1 * W = (-2,4,-1,2)
Wodruch wir für unsere Kurve folgende Formel erhalten:
f(t) = t^3 * (-2) + t^2 * 4 + t * (-1) + 2
Da die Dimensionen hier ebenfalls unabhängig sind, können Hermit-Kurven auf beliebig viele Dimensionen erweitert werden.

Das Ergebnis sieht nun folgendermaßen aus:

[[Bild:InterpolationBsp3.PNG]]

''Oben angegebenes Beispiel grafisch dargestellt. Die beiden Punkte sind rot dargestellt, die beiden Tangenten sind als blaue Geraden eingezeichnet. Die Kurve beinhaltet alle Punkte der gegebenen Funktionen für t im Wertebereich [0|1].''

=Tangenten von Kurven=
Besitzt man die Funktion für eine Kurve so lässt sich die Tangente durch das differenzieren dieser Funktion ermitteln. Aus unserem vorigen Beispiel wäre dies:
f(t) = t^3 * (-2) + t^2 * 4 + t * (-1) + 2
f'(t) = -6 * t^2 + 8 * t - t
Da die Dimensionen einer derartigen Kurve wie gesagt unabhängig voneinander behandelt werden können, kann man dadurch die Tangente in der entsprechenden Dimension erhalten.

= Interpolation mit anderen Funktionen =
Bisher wurden nur Interpolationen gezeigt, bei denen der t-Wert potenziert wurde. Es wurde immer ein Anfangspunkt verwendet, für den der t-Wert 0 sein sollte, und ein Endpunkt für den der t-Wert 1 sein sollte. Wir können natürlich jede beliebige Funktion für die Interpolation verwenden wo dies zutrifft. Wenn wir möchten können wir natürlich auch eine Funktion verwenden wo der Anfangspunkt bei t=X und der Endpunkt bei t=Y zu finden ist, denn eine derartige Funktion können wir wiederum umformen zu einer Funktion für die wir einen Anfangspunkt mit t=0 und einen Endpunkt mit t=1 haben.

Andere Funktionen werden meistens (nicht immer) bei nur 2 gegebenen Punkten verwendet. Hier wird meistens aus einem t-Wert im Bereich [0|1] ein neuer Wert u im Bereich [1|0] berechnet, welcher danach ähnlich wie bei der linearen Interpolation verwendet wird. Also:
u = f(t)
Interpolierter_Wert = I(t) = u * Startwert + (1-u) * Endwert
Wobei:
f(t) ... die Interpolationsfunktion, welche bei t=0 1 zurück liefert und bei t=1 0 ist.
Interpolierter_Wert ... das Ergebnis.

Mögliche andere Funktionen sind nun beispielsweise:

== Cosinus ähnliche Interpolation ==

===Cosinus Interpolation===
Der Cosinus liefert Werte zwischen -1 und 1. Wir wollen einen eindeutigen y-Wert für y=Cos(t), somit verwenden wir nur t-Werte im Wertebereich von 0 bis 180 Grad (bzw. 0 bis Pi Radianten), denn bei t=181 Grad würden wir ja den selben Wert erhalten wie für t=179 Grad.

Der t-Wert wird für den Cosinus im Wertebereich [0|Pi] bzw. [0|180Grad] benötigt. Um nun einen t-Wert (wie zuvor) im Wertebereicheich von [0|1] verwenden zu können, multiplizieren wir ihn einfach mit Pi. Also verwenden wir einfach
t2 = t * Pi
bzw. das Ganze mit Grad:
t2 = t * 180

Der Ausgabewert von Cosinus ist im Wertebereich [1|-1]. Um ihn auf den Wertebereich [1|0] zu bringen, müssen wir ihn transformieren. Dafür formen wir um:
f(t2) = Cos(t2)
g(t2) = f(t2)/2 + 1/2 = ( 1 + f(t2) ) / 2 = ( 1 + Cos(t2) ) / 2
Und nun noch t2 durch t ersetzt:
g(t) = ( 1 + Cos(t*Pi) ) / 2
bzw. das Ganze mit Grad:
g(t) = ( 1 + Cos(t*180) ) / 2

Wir haben nun eine Formel die uns bei t=0 einen Wert von 1 liefert und bei t=1 einen Wert von 0. Dies können wir in unsere allgemeine Funktion einsetzen:
Interpolierter_Wert = I(t) = g(t) * Startwert + ( 1 - g(t) ) * Endwert
Und für g(t) eingesetzt:
Interpolierter_Wert = I(t) = ( (1+Cos(t*Pi))/2 ) * Startwert + ( 1 - (1+Cos(t*Pi))/2 ) * Endwert
bzw. das Ganze mit Grad:
Interpolierter_Wert = I(t) = ( (1+Cos(t*180))/2 ) * Startwert + ( 1 - (1+Cos(t*180))/2 ) * Endwert

Nun die Frage warum der ganze Aufwand, also warum nicht linear interpolieren? Um dies zu beantworten müssen wir die Steigungen dieser Funktion betrachten, wofür wir die Ableitung der Funktion berechnen:
I'(t) = 1/2 * Endwert * Pi * Sin( t * Pi ) - 1/2 * Startwert * Pi * Sin( t * Pi )
Sieht kompliziert aus, aber wenn wir nun t=0 annehmen so erhalten wir für Sin( t * Pi ) ebenfalls 0. Wenn wir für t=1 annehmen so erhalten wir für Sin( t * Pi ) wiederum 0. Und dadurch erhalten wir an beiden Enden eine Steigung von 0.

Was können wir machen mit einer Funktion die an beiden Enden eine Steigung von 0 aufweist? Ganz einfach: wir können mehrere dieser Funktionen aneinander reihen, ohne das man einen übergang erkennt. Somit können wir sagen:
Bei t im Bereich [0|1] verwende als Startwert 3 und als Endwert 1
Bei t im Bereich ]1|2] verwende als Startwert 1 und als Endwert 7
Bei t im Bereich ]2|3] verwende als Startwert 7 und als Endwert 8
Und wenn wir alle 3 Funktionen mit dem Wertebereich [0|1] verwenden (oder mathematisch ausgedrückt: I2(t) = I(t modulo 1) ), so erhalten wir eine Kurve ohne Kanten, oder um es etwas mathematischer auszudrücken: diese Funktion ist im Wertebereich ]0|3[ ableitbar, also in diesem Wertebereich auch stetig.

Und um die Ästhetik hinter diesen Formeln zu zeigen, ein Vergleich von linearer- zu cosinus-Interpolation:

[[Bild:Interpolation.png]]

=== Quadratische Annäherung der Cosinus Interpolation ===
Da die Berechnung des Cosinus eine etwas aufwändigere Angelegenheit ist, wünscht man sich hin und wieder eine Funktion die ähnlich aussieht und die gleichen Bedingungen (also eine Steigung von 0 an Start- und Endpunkt) erfüllt. Hierfür kann man 2 quadratische Funktionen verwenden die folgendes erfüllen müssen:
#Beide Kurven müssen einen gemeinsamen Punkt besitzen, also I1(t) = I2(t) für t im Wertebereich [0|1]
#An diesem Punkt müssen beide Kurven die selbe Steigung besitzen, also es existiert ein ( I1(X) = I2(X) wo auch gilt I1'(X) = I2'(X) ).
#Steigung (also Ableitung) bei t=0 und t=1 soll 0 sein
#Die Kurve sollte symmetrisch sein bezogen auf t=0.5, so das gilt: I1(t) = 1-I2(1-t). Somit muss gleichzeitig der Punkt wo gilt I1(t) = I2(t) bei 0.5 liegen.

Wir können uns nun aus der ersten und dritten Bedinung einfach die beiden Formeln herleiten, aber um es kurz zu machen:
Wenn t <= 0.5 dann I1(t) = -2*t^2 + 1
Wenn t > 0.5 dann I2(t) = 2*t^2 - 4*t + 2 = 2 * (1-t)^2
Nun zeigen wir, dass die oben angegebenen Bedingungen erfüllt sind:
#I1(0.5) = -2*0.5^2 + 1 = 0.5; I2(0.5) = 2 * (1-0.5)^2) = 0.5
#I1'(t) = -4t, I1'(0.5) = -2; I2'(t) = 4*t - 4, I2'(0.5) = -2
#I1'(0) = -4*0 = 0; I2'(1) = 4*1 - 4) = 0
#I1(t) = 1-I2(1-t) '''=>''' -2*t^2 + 1 = 1 - (2*(1-t)^2 - 4*(1-t) + 2) '''=>''' -2*t^2 + 1 = 1 - (2 - 4*t + 2*t^2 - 4 + 4*t + 2) '''=>''' -2*t^2 + 1 = -2*t^2 + 1

=== Cosinus ähnliche Interpolation durch Polynominterpolation ===
Wenn wir eine Polynominterpolation mit den beiden Endtangenten 0 berechnen wollen, so verwenden wir eine Hermite Kurve. Hierbei verwenden wir die Werte:
1 ... Startpunkt
0 ... Endpunkt
0 ... Steigung bei Startpunkt
0 ... Steigung bei Endpunkt
Mit der unter Hermit Kurven angegebenen Matrix M^-1 können wir uns nun die dazugehörige Funktion berechnen und erhalten:
I(t) = 2*t^3 - 3*t^2 + 1
Die ersten beiden Bedingungen von vorher sind automatisch erfüllt, da es sich nur um eine Funktion handelt. Für die 3. und 4. Bedingung lässt sich ebenfalls verhältnismäßig einfach zeigen das sie erfüllt sind.

=== Vergleich der Cosinus ähnlichen Interpolationsarten ===
Und zu guter letzt hier noch die grafische Veranschaulichung der etwas zahlenbeladenen Funktionen.

[[Bild:InterpolationCosAnnaeherung.png]]

''Die 3 Cosinus ähnlichen Funktionen graphisch dargestellt:
*Grün: Cos-Interpolation
*Rot: Polynom-Interpolation
*Blau: Quadratische Annäherung''

=Interpolierte Flächen=
Bisher wurden ausschließlich Kurven betrachtet. Aus Kurven lassen sich jedoch ohne größere Umstände auch Flächen bilden. Hier hat man zwei (unterschiedliche) t-Werte und eine Matrix von Punkten gegeben, wobei jeder Punkt gegebenenfalls noch 1 oder 2 Tangenten besitzen kann. Um einen Punkt einer Fläche zu berechnen interpoliert man zuerst die Punkte für jede Zeile der Punktmatrix. Nachdem man nun die interpolierten Punkte für jede Zeile besitzt kann man sich mit diesen Punkten ein neues Gleichungssystem aufstellen und wiederum eine Kurve bilden. Diese Kurve interpoliert man wiederum mit dem zweiten gegebenen t-Wert. Dies lässt sich auf beliebig viele Dimensionen nach dem gleichen Schema erweitern, üblicherweise wird dies jedoch nur für Oberflächen (also 2D) benötigt.

==Normalvektoren==
Besitzt man Flächen und berechnet sie nach dem gegebenen Schema, so berechnet man sich zuerst auch mehrere Kurven von denen man die Tangenten berechnen kann. Interpoliert man nun diese Tangenten mit der gleichen Kurvenfunktion wie die resultierenden Punkte, und berechnet sich aus der resultierenden Kurvenfunktion ebenfalls die Tangente, so erhält man 2 Tangenten. Aus diesen beiden Tangenten kann nun mit einem Kreuzprodukt ein Normalvektor errechnet werden.

=Kurvenlängen-Interpolation=
Es könnte erwünscht sein (beispielsweise für Kamerafahrten, Keyframe Interpolationen jeglicher Art oder auch bei der Interpolation von Positionsangaben die man beispielsweise über ein Netzwerk erhält), dass man über keine fixe Achse t interpolieren möchte, sondern über die Kurvenlänge.

Bei den typischen physikalischen Beispielen besitzt man meist eine Geschwindigkeit welche durch Beschleunigung verändert wird. Also wenn man einen Ball senkrecht hoch wirft, so gibt es einen Punkt an dem er komplett stehen bleibt. Für diese Art von physikalischen Berechnungen wird man also kaum eine Kurvenlängen-Interpolation benötigen.

Wenn man jedoch sehr langsame Geschwindigkeiten besitzt, also beispielsweise zu fuß geht, so haben wir eine nahezu konstante Gehgeschwindigkeit, egal ob wir eine Kurve gehen oder nicht. Wenn wir noch weiter gehen und auf einer Straße oder einer Rennstrecke alle 100 Meter ein Längenangabenschild hin stellen möchten, so ist uns Beschleunigung und auch die Geschwindigkeit vollkommen egal. Wir hätten also am liebsten eine Funktion P(s), welche uns den Punkt der Kurve für für Kilometer (oder Meter) s liefert.

==Der eindimensionale Fall==
Dieser Teil soll lediglich als Erklärung dienen, besitzt in der Praxis aber kaum Relevanz.

Im Eindimensionalen Fall kann man sich dies noch sehr gut veranschaulichen. Wenn ich eine gerade Strecke besitze und meine 1D-Koordinaten kenne, so kann ich ganz einfach sagen: zum Zeitpunkt t bin ich Betrag( f(t) - f(t0) ) Meter (allg. Einheiten) gegangen. Interessant wir es noch mal wenn ich die Richtung ändere, also wenn ich bei Kilometer 4 merke das ich etwas zu Hause vergessen habe, noch einmal umdrehe und dann weiter fahre. In diesem Fall kann ich nicht sagen: ich befinde mich an Position 10 Kilometer entfernt => ich bin 10 Kilometer gegangen, sondern in Wirklichkeit habe ich noch zusätzlich 8 Kilometer umweg hinter mir.

Dieses simple beispiel mathematisch ausgedrückt:

wenn f(t) monoton steigend oder monoton fallend ist: Kurvenlänge(t) = | f(t) - f(t0) |
Sonnst: Kurvenlänge = Integral[t0 bis t]( f'(t) )
Beim Integrieren müssen wir nun aufpassen, ob unsere Stammfunktion 0-Stellen besitzt. Bei jeder solchen 0-Stelle Zx zerteilen wir die Wertebereiche:
W = [t0, Z1, Z2, Z3, ..., Zn, t]

Kurvenlänge(t) = Summe[ n=1 bis Elemente von W ]( Integral[W[n-1] bis W[n]]( f'(t) )
Da wir nun in der Stammfunktion alle 0-Stellen berücksichtigt haben können wir das Integral "kürzen", also
Kurvenlänge(t) = Summe[ n=1 bis Elemente von W ]( | f(w[n]) - f(w[n-1]) | )

Das Integral macht hier also nichts anderes als Richtungswechsel zu erkennen, denn bei einem Richtungswechsel in 1D ändert sich das Vorzeichen der Ableitung einer Funktion, und für jeden Vorzeichenwechsel muss es auch einen 0-Punkt geben wenn es sich um eine stetige Funktion handelt.

Wir kennen nun also den Weg den wir zu einem bestimmten Zeitpunkt zurückgelegt haben. Wir wollen jedoch den Zeitpunkt wissen an dem wir eine bestimmte Weglänge zurückgelegt haben, um die Funktion f(t) durch f(t(s)) = g(s) wodurch g(s) eine Funktion ist wo wir die Position für einen bestimmte Kurvenlänge erhalten.

Wir müssen also ein t finden für das gilt
Kurvenlänge(t) = s
und können danach dieses t in unsere Ursprüngliche Kurvengleichung einsetzen.

Und nun mit voller Wucht: warum bringt uns das alles ganz und gar nichts?
Wenn wir eine Eindimensionale "Kurve" besitzen und wir wollen diese über die Kurvenlänge parametrisieren, so sagen wir schlicht und ergreifend:
x = x0 +/- s
wenn wir nicht mehrere Fälle besitzen. Wenn wir Fallunterscheidungen bekommen, so gibt es (wie im mehrdimensionalen Fall noch verdeutlicht wird) natürlich auch Methoden mit denen wir diese Fallunterscheidungen umgehen können (namentlich: numerische Integration). Dennoch ist die Funktion wohl in nahezu allen Fällen einfacher mit derartigen Fallunterscheidungen zu berechnen.

===Beispiel===
Ein Beispiel noch am Rande, wie man unschwer erahnen kann, gibt es eher wenig alltäglichere Beispiele die nicht zu trivial und von Interesse wären:

Wir besitzen eine gedämpfte Schwingung mit der Formel
f(t) = e^(-t) * sin(t)
und möchten aus unerfindlichen Gründen wissen wo sich der schwingende Körper befindet wenn er den Weg s zurückgelegt hat.

Wir berechnen uns die Ableitung
f'(t) = e^(-t) * cos(t) - e^(-t) * sin(t)
und nun die 0-Stellen, also
f'(t) = 0
davon gibt es aber natürlich jede Menge ... aber wir begnügen und mit den ersten 3:
f'(PI/4) = 0 | f(PI/4) ~= 0.322
f'(~3.927) = 0 | f(3.927) ~= -0.014
f'(~7.069) = 0 | f(7.069) ~= 0.0006
Da der Startpunkt (t=0) natürlich auch bei 0 liegt, erhalten wir also jetzt für unsere Position in Abhängigkeit der Weglänge s:
g(s) = s für s im Bereich [0,0.322]
g(s) = 2*0.322-s für s im Bereich ]0.322|0.658] wobei 0.658 = 0.322 + | 0.322-0.014 |
g(s) = s-2*0.322-2*0.014 für s im Bereich ]0.658|0.6585] wobei 0.6586 = 0.322 + | 0.322 - (-0.014) | + | -0.014 - 0.0006 |

==Kurven in höheren Dimensionen==
Im allgemeinen Fall kann eine Kurve in einer bestimmten Dimension als Vektor von Funktionen dargestellt werden:
| x(t) |
P(t) = | y(t) |
| z(t) |
| ... |
wir können die Tangente berechnen indem wir in jeder Dimensionen die Funktion ableiten:
| x'(t) |
T(t) = | y'(t) |
| z'(t) |
| ... |
und natürlich handelt es sich nun nicht um irgendeine Tangente, sondern um die Tangente welche auch die Änderungsgeschwindigkeit der Kurve abhängig von t beschreibt. Wir können die Länge dieser Tangente also als Geschwindigkeit der Kurve betrachten. Die Länge eines Vektors ist ein skalarer Wert, also erhalten wir für die Geschwindigkeit zu einem Zeitpunkt t die Funktion:
Geschwindigkeit(t) = | T(t) |
Der Betrag der Tangente wir nun folgendermaßen gebildet:
Geschwindigkeit(t) = Wurzel( x'(t)^2 + y'(t)^2 + z'(t)^2 + ... )
Nun besitzen wir eine Funktion für die Geschwindigkeit der Kurve welche uns integriert die Länge der Kurve bis zum Zeitpunkt t angibt. Im Gegensatz zum eindimensionalen Fall (wo dies eher wenig Sinn hatte) quadrieren wir hier jeden verwendeten Wert, wodurch diese Funktion niemals < 0 werden kann, somit müssen wir beim integrieren auch nicht auf 0-Stellen aufpassen.

Wir Integrieren nun:
Kurvenlänge(t) = Integral[t0 bis t]( Geschwindigkeit(t) )

Und hier stoßen wir an einen unangenehmen Punkt. Nehmen wir ein "einfaches" Polynom für x(t), y(t) und z(t). An einem Integral wie aus unserem Polynom-Beispiel:
Integral[t0 bis t]( Wurzel( (-58.5*t^3 + 90*t^2 - 35.5*t + 5)^2 + (22.5*t^3 - 36*t^2 + 12.5*t + 3)^2 ) )
scheitern sogar gute Mathematik-Bibliotheken, und von normalsterblichen Menschen ganz zu schweigen.

Doch noch ist nicht alles Verloren, wir können uns der Lösung recht gut annähern. Bestimmte Integrale können wir mit numerischen Verfahren lösen, wodurch es zumindest möglich ist ein entsprechendes t anzunähern und mit entsprechenden Näherungsverfahren können wir uns auch verhältnismäßig schnell und gut annähern.

===Numerische Integration===
Da dieser Teil wohl etwas zu ausschweifend wäre möchte ich hier nur die Grundlegende Idee und eine sehr einfache Methode erwähnen.

Bei numerischen Verfahren wählt man üblicherweise ein paar Punkte der zu integrierenden Funktion aus und berechnet den Flächeninhalt des Kurvenstückes indem man häufig sehr grobe Annäherungen verwendet. Die wohl naivste Methode ist, wenn man sagt:
Integral[a bis b]( f(x) ) ~= | (b-a) * f( (b+a)/2 ) |
Also man berechnet sich den Flächeninhalt des Rechtecks, mit der Breite des entsprechenden Kurvenstückes und einem Punkt der Kurve (in diesem Fall der Punkt in der Mitte des Stückes).

Eine andere sehr bekannte Methode verwendet statt Rechtecken Trapeze und benötigt dafür natürlich bereits 2 Punkte der Kurve:
Integral[a bis b]( f(x) ) ~= | (b-a) * ( f(a) + f(b) )/2 |

Da eine solche Annäherung natürlich erfolgversprechender wird, desto kleiner der Abstand zwischen a und b ist, wird man üblicherweise einen größeren Bereich in mehrere (oder sogar sehr viele) kleinere Bereiche unterteilen:
Integral[a bis b]( f(x) ) = Integral[a bis k1]( f(x) ) + Integral[k1 bis k2]( f(x) ) + ... + Integral[kn bis b]( f(x) )
Je kleiner die Teilbereiche werden, umso genauer wird das Ergebnis.

Generell kann man wohl sagen, dass bei komplexeren Integralen ein guter Mittelweg zu finden ist zwischen Genauigkeit und Rechenaufwand, sofwohl was die Anzahl der Teilstücke, als auch die Qualität der Berechnung der Teilstücke betrifft.

===Näherungsverfahren===
Auch hier gibt es mehrere Varianten, da es sich jedoch um eine monoton wachsende Funktion handelt, sind wohl alle Varianten brauchbar, wenn einige davon aber dennoch endlos um das Ziel herum oszillieren können. Wir besitzen nun eine Methode mit der wir beispielsweise das oben problematische Integral ganz gut annähern können. Wir können also jetzt bestimmten:
Im Zeitraum t0 bis t hat die Kurve eine Länge s.
Wir möchten aber nun für einen Länge s einen Zeitpunkt t (in Abhängigkeit von t0) finden. Dies erreichen wir, indem wir uns möglichst schnell an dieses t annähern. Ein Beispiel dafür ist das Newtonsche Näherungsverfahren. Wiederum soll jedoch nur ein grober Überblick über die Materie gegeben werden.

Wenn wir einen Zielwert (der Einfachheit halber immer f(x) = 0 ) besitzen, einen aktuellen Wert X1 und f(X1) = k, so wissen wir bei einer monoton steigenden Funktion bereits ob wir nach links oder nach rechts müssen. Ist k größer als 0 so müssen wir nach links. Ist k kleiner 0, so müssen wir nach rechts. Des weiteren können wir uns noch die Steigung der Funktion am Punkt X1 berechnen, wodurch wir auch eine recht gute Ahnung davon bekommen wie weit wir uns bewegen sollen. Dafür nehmen wir an, dass die Steigung annähernd gleich bleibt. Nun berechnen wir uns wie weit wir bei gleich bleibender Steigung gehen müssen und erhalten so unser X2. Diesen Vorgang wiederholen wir so lange bis wir einen genügend genauen Wert besitzen, oder der Wert längere Zeit nicht mehr genauer wird. Die Formel dafür lautet:
X(n+1) = Xn - f(Xn) / f'(Xn)
Und somit haben wir alle Werkzeuge zur Verfügung die wir benötigen, denn nun können wir den 0-Punkt der Funktion
Integral[t0 bis t]( f(x) ) - s = 0
annähern, so dass wir ein t erhalten welches die gesuchte Weglänge gut annähert. Diese t können wir danach in unsere Formel ganz normal einsetzen und somit erhalten wir die Position und bei Bedarf natürlich auch wieder die Tangente oder einen Normalvektor.

===Beispiel===
Wir verwenden hier wieder eine Kurve im 2D-Raum welches wie unter "Polynome höheren Grades" aus 4 Punkten erstellt wurde. Ohne große Umschweife hier die beiden Formeln:
Ix = -31.5*t^3 + 58.5*t^2 - 28*t + 5
Iy = 22.5*t^3 - 36*t^2 + 12.5*t + 3

Wir implementieren diese direkt (also hardgecodet) um den Quellcode eher kurz und einfach zu halten (bisher C-Code):
/* x Wert der Kurve in Abhängigkeit der Zeit */
double func_x( double t )
{
return 5.0 - 28.0*t + 58.5*t*t - 31.5*t*t*t;
}

/* func_x'(t) also func_x abgeleitet. Ein Polynom lässt sich sehr einfach
* ableiten, der Einfachheit halber jedoch auch hier direkt angegeben.
*/
double func_dx( double t )
{
return -28.0 + 117.0*t - 94.5*t*t;
}

/* y Wert der Kurve in Abhängigkeit der Zeit */
double func_y( double t )
{
return 3.0 + 12.5*t - 36.0*t*t + 22.5*t*t*t;
}

/* func_y'(t) also func_y abgeleitet */
double func_dy( double t )
{
return 12.5 - 72.0*t + 67.5*t*t;
}

/* Weg in Abhängigkeit der Zeit abgeleitet. */
double func_ds( double t )
{
return sqrt( func_dx(t)*func_dx(t) + func_dy(t)*func_dy(t) );
}

Nun der erste etwas interessantere Teil, das numerische integrieren von func_ds:
/* Liefert eine Annäherung an das Integral von func mit den Schranken a und b.
* Parameter:
* a: untere Schranke
* b: obere Schranke
* sections: Anzahl der verwendeten Trapeze zur Annäherung, je höher desto genauer die Annäherung
* Wenn b kleiner als a ist, so wird ein negativer Wert zurück gegeben.
*/
double NIntegrate( double a, double b, int sections )
{
int d;
double sum = 0.0;
double pos = a;
double pos2 = a + (b-a)/(double)sections;
double f = func_ds( pos );
double f2;

for( d=0; d<sections; d++ )
{
f2 = func_ds( pos2 );

sum += fabs( (f+f2)*0.5*(b-a)/(double)sections );

pos = pos2;
pos2 += (b-a)/(double)sections;

f = f2;
}

// Ist die untere Schranke a größer als die obere Schranke b, so negiere den Wert
if( a > b )
return -sum;
else
return sum;
}
Mit dieser Funktion können wir uns nun bereits berechnen wie viel Weg zu einem Zeitpunkt t zurück gelegt wurde. Ein Beispiel hierfür folgt noch weiter unten. Um uns für einen gegebenen Weg s an einen Zeitpunkt t anzunähern an dem wir den Weg zurück gelegt haben, verwenden wir nun ein Näherungsverfahren. Wir wollen die Funktion
f(x) = Integral[0 bis t]( func_ds(x) ) - s
an 0 annähern. Für das Newton-Verfahren benötigen wir noch die Ableitung von f(x):
f'(x) = func_ds(x)
und nun können wir folgende Formel verwenden:
Xn+1 = Xn - (Integral[ 0 bis Xn ]( func_ds(x) ) - s) / func_ds(Xn)
Und genau das machen wir in folgender Funktion:
/* Nähert den Wert t für
* Integral[0 bis t]( func_ds(x) ) = Value
* an.
* Parameter:
* start: ein möglichst genau geschätzter Wert mit dem die Annäherung begonnen werden soll.
* Value: Zielwert nach obiger Formel.
* depth: Anzahl der Iterationen (bzw. um genau zu sein der Rekursionen) je höher dieser Wert desto genauer das Ergebnis
* sections: Wird an NIntegrate weitergereicht, je höher dieser Wert desto genauer das Ergebnis
*/
double FindValue( double start, double Value, int depth, int sections )
{
double newval;
double f = func_ds( start );

if( depth <= 0 )
return start;

// verhindert Division durch 0. Extrem kleine Werte _könnten_ auch problematisch sein.
if( f < 0.0000001 && f > -0.0000001)
{
if( f >= 0.0f )
newval = start - (NIntegrate( 0.0, start, sections ) - Value);
else
newval = start + (NIntegrate( 0.0, start, sections ) - Value);
}
else
{
// die Unterscheidung ob start > 0 ist wird bereits von NIntegrate durchgeführt
newval = start - (NIntegrate( 0.0, start, sections ) - Value) / f;
}

return FindValue( newval, Value, --depth, sections );
}
Nun noch das ein oder andere Beispiel wie wir diese Funktionen verwenden:
/* Beispielshafte Verwendung der Funktionen */
void main()
{
double FullKurveLength = NIntegrate( 0.0, 1.0, 100 );
double TforS;
double KurveLength;

printf( "Die gesamte Kurvenlaenge (von Zeitpunkt 0 bis 1) betraegt ziemlich genau: %f\n", FullKurveLength );

printf( "\n" );

/* Parameter:
* a = 0.0: Wir möchten den zurückgelegten Weg angefangen von Zeitpunkt 0.0
* b = 0.5: Wir möchten den zurückgelegten Weg bis zum Zeitpunkt 0.5, also von 0.0 bis 0.5
* sections = 10: liefert wahrscheinlich ein eher ungenaues Ergebnis.
*/
KurveLength = NIntegrate( 0.0, 0.5, 10 );
printf( "Ungeneau: in der haelfte der Zeit wurde %f Weg zurueck gelegt.\n", KurveLength );

KurveLength = NIntegrate( 0.0, 0.5, 20 );
printf( "Etwas geneauer: in der haelfte der Zeit wurde %f Weg zurueck gelegt.\n", KurveLength );

KurveLength = NIntegrate( 0.0, 0.5, 100 );
printf( "Recht geneau: in der haelfte der Zeit wurde %f Weg zurueck gelegt.\n", KurveLength );

printf( "\n" );

/* Parameter:
* start = 0.5: wir schätzen das der halbe Weg zum Zeitpunkt 0.5 zurück gelegt wurde
* Value = FullKurveLength * 0.5: wir möchten wissen zu welchem Zeitpunkt der halbe Weg zurück gelegt wurde
* depth & sections = 0: liefert wahrscheinlich ein eher ungenaues Ergebnis.
*/
TforS = FindValue( 0.5, FullKurveLength * 0.5, 5, 10 );
printf( "Ungenau: zum Zeitpunkt %f wurde der halbe Weg zurueck gelegt.\n", TforS );

TforS = FindValue( 0.5, FullKurveLength * 0.5, 10, 20 );
printf( "Etwas genauer: zum Zeitpunkt %f wurde der halbe Weg zurueck gelegt.\n", TforS );

TforS = FindValue( 0.5, FullKurveLength * 0.5, 50, 100 );
printf( "Recht genau: zum Zeitpunkt %f wurde der halbe Weg zurueck gelegt.\n", TforS );
};
Als ausgabe dieses Tests erhalten wir:
Die gesamte Kurvenlaenge (von Zeitpunkt 0 bis 1) betraegt ziemlich genau: 9.201214

Ungeneau: in der haelfte der Zeit wurde 5.582572 Weg zurueck gelegt.
Etwas geneauer: in der haelfte der Zeit wurde 5.558352 Weg zurueck gelegt.
Recht geneau: in der haelfte der Zeit wurde 5.550576 Weg zurueck gelegt.

Ungenau: zum Zeitpunkt 0.376217 wurde der halbe Weg zurueck gelegt.
Etwas genauer: zum Zeitpunkt 0.378924 wurde der halbe Weg zurueck gelegt.
Recht genau: zum Zeitpunkt 0.379795 wurde der halbe Weg zurueck gelegt.
Wir können uns nun auch die Zeitpunkte ausrechnen an denen 10%, 20%, ... des Weges zurück gelegt wurde und uns die Punkte auf der Kurve einzeichnen um auch einen visuelleren Vergleich zu erhalten:

[[Bild:KurvenlaengenInterpolation.gif]]

Rot: Die Punkte zu den Zeitpunkten 0.0, 0.1, 0.2, ..., 0.9, 1.0

Blau: Die Punkte zu denen 0%, 10%, 20%, ..., 90%, 100% des Weges zurück gelegt wurde angenähert durch FindValue(...) mit depth = 5 und sections = 10

Grün: Die Punkte zu denen 0%, 10%, 20%, ..., 90%, 100% des Weges zurück gelegt wurde angenähert durch FindValue(...) mit depth = 50 und sections = 100

Gut zu erkennen ist auf diesem Bild auch, dass 10 Unterteilungen für einen das Integrieren von 0 bis 0.1 noch ganz gute Ergebnisse liefert, jedoch bei einem Wertebereich von 0 bis 1 schon ziemlich ungenau wird, somit macht es durchaus Sinn die Anzahl der Unterteilungen auch abhängig von der Größe des Bereiches zu machen.

Interpolation

2006-06-17T17:07:30Z

Lyr: /* Kurvenlängen-Interpolation */ C -> Pascal wär wieder mal gefragt

Bei Interpolationsverfahren geht es darum, aus wenigen Werten beliebig viele Werte zu generieren. Da die gegebenen Werte - wo Interpolation nötig ist - meistens als Stichproben gesehen werden können, werden verschiedenste Verfahren benötigt um auch die nicht gegebenen Werte den Ansprüchen entsprechend zu berechnen. Die Ansprüche variieren hierbei etwas anhand der Geschwindigkeitsanforderungen, des Zahlenraumes und nicht zuletzt anhand der Art und Weise wie man interpolieren möchte.

=Polynom Interpolationen=
Wenn man N gegebene Werte hat, so kann man diese mit einem Polynom (N-1)ten Grades interpolieren. Eine Polynom Interpolationen besitzen die allgemeine Form:
I = (t^n)*Fn + (t^(n-1))*F(n-1) + ... + t*F1 + F0
Wobei:
t ... die Interpolationsposition im Wertebereich [0|1]
Fx ... ein konstanter Wert oder Faktor (oder allgemein ein m-Dimensionaler Vektor)
I ... das interpolierte Ergebnis, was ebenfalls ein einzelner Wert oder ein Vektor sein kann.
Durch die Vektor-Schreibweise sollte bereits klar sein, dass Polynom-Interpolationen für jede Dimension extrig berechnet werden, und somit auf beliebig viele Dimensionen erweiterbar sind.

== Lineare Interpolation ==
=== Allgemein ===
Die einfachste Form einer Polynom-Interpolation ist die lineare Interpolation. Hierbei sind nur 2 Werte gegeben, somit kann man diese Werte mit einem Polynom ersten Grades interpolieren. Dieses ist (wie unschwer zu erraten) eine Gerade der Form:
I = t*F1 + F0
Diese (eher ungewöhnliche) Form der Geradengleichung entspricht der oben angegebenen Polynom-Interpolation in beliebiger Dimension. Die Berechnung der Faktoren Px erfolgt hier für jede Dimension getrennt. Gegeben seien 2 m dimensionale Punkte (A1, A2, ..., A(m-1), Am) und (B1, B2, ..., B(m-1), Bm). Nun lässt sich für jede Dimension d ein einfaches Gleichungssystem aufstellen:
Ad = 0*F1d + F0d
Bd = 1*F1d + F0d
da wir mit einem Interpolationswert von 0 den ersten Punkt (A) erhalten wollen und einem Interpolationswert von 1 den zweiten Punkt (B) möchten. Dies umgeformt auf P1d und P0d ergibt:
F0d = Ad
F1d = Bd - Ad
Diesen Rechenschritt wiederholen wir für jede Dimension.

=== Rechenbeispiel ===
Wir wollen 2 Punkte im 3 dimensionalen Raum interpolieren:
A: (2|5|0)
B: (4|1|8)
Wir berechnen uns die Vektoren P1 und P0 wie oben angegeben, wobei x die erste und z die dritte Dimension dar stellen soll:
F0x = Ax = 2
F1x = Bx - Ax = 2
F0y = Ay = 5
F1y = By - Ay = -4
F0z = Az = 0
F1z = Bz - Az = 8
Somit erhalten wir die unsere Interpolationsgleichung:
I(x|y|z) = t * (2|-4|8) + (2|5|0)

Das Ergebnis sieht nun folgendermaßen aus:

[[Bild:InterpolationBsp1.png]]

''2 dimensionale Version des obigen Beispieles. Die gegebenen Punkte sind somit A(2|5) und B(4|1). Diese Punkte sind in rot dargestellt. Die Gerade beinhaltet alle Punkte für die gegebene Formel mit t im Wertebereich [0|1]''

== Polynome höheren Grades ==
=== Allgemein ===
Wie euch vielleicht schon bei der linearen Interpolation aufgefallen ist, ist eine Reihung der Punkte (vorher nur 2) erforderlich. Welcher PUnkt soll das Ergebnis mit t = 0 sein? Und welcher mit t=1? Wenn man mehr als 2 Punkte gegeben hat, so benötigt man zusätzlich noch die Informationen für welches t die beiden neuen Punkte gelten sollen. Meistens interpoliert man hier die Werte für t linear. Das heißt bei N gegebenen Punkten, soll der x-te Punkt für den t-Wert
t(Px) = x / (N-1) + 0
gegeben werden. Wobei:
t(Px) ... der t-Wert für den x-ten Punkt
Das (N-1) der Gleichung wird uns noch länger verfolgen, deshalb werden wir im weiteren Verlauf N-1 als n bezeichnen. Hier noch kurz die Anmerkung, dass man bei einem gegebenen Punkt natürlich keine Parameter benötigt sondern der Punkt immer gleich ist. Man kann sich dies (und alles darauffolgende) auch so vorstellen, dass wir den ersten gegebenen Punkt F0 als 0-Punkt annehmen und erst am "Ende" F0 addieren. Aus dieser Sichtweise heraus bekommen wir unser n = N-1.

Nun lässt sich wiederum das allgemeine (lineare) Gleichungssystem auffstellen:
P0 = t(P0)^n * Fn + t(P0)^(n-1) * F(n-1) + ... + t(P0) * F1 + F0
P1 = t(P1)^n * Fn + t(P1)^(n-1) * F(n-1) + ... + t(P1) * F1 + F0
...
Pn = t(Pn)^n * Fn + t(Pn)^(n-1) * F(n-1) + ... + t(Pn) * F1 + F0
Wobei:
Px ... der x-te Punkt
t(Px) ... der t-Wert für den x-ten Punkt
Fy ... der zu berechnende Faktor
Also ein Gleichungssystem mit n unbekannten und n (linear unabhängigen) Gleichungen, welches sich demnach eindeutig lösen lässt. Wobei dieses Gleichungssystem wiederum für jede Dimension extrig aufgestellt und berechnet werden muss! Da man (eindeutig lösbare) Gleichungssystem recht angenehm durch Matrizen-Mathematik lösen kann, empfiehlt sich auch folgende Schreibweise:
P = M * F
Wobei:
P ... ein N dimensionaler Vektor der die gegebenen Werte für den jeweiligen Punkt beinhaltet
M ... eine NxN Matrix welche die t(Px)^y beinhaltet
F ... ein N dimensionaler Vektor der die zu berechnenden Faktoren erhält
und N ... wie gehabt die Anzahl der gegebenen Punkte und n = N - 1

Dies kann man nun umformen in:
M^-1 * P = F
Wobei:
M^-1 ... die inverse von M ist

Dadurch erhält man alle Werte Fy die man benötigt und kann somit für ein gegebenes t wiederum in die allgemeine Form:
I = (t^n)*Fn + (t^(n-1))*F(n-1) + ... + t*F1 + F0
einsetzen.

=== Rechenbeispiel ===
Wir wollen über 4 Punkte eine Polynominterpolation im 2 dimensionalen Raum. Diese sind:
P0: (5|3)
P1: (1|4)
P2: (4|2)
P3: (1|2)
Wir legen nun zuerst wieder die t-Werte für die Punkte fest, und sagen:
P0 bei t=0
P1 bei t=1/3
P2 bei t=2/3
P3 bei t=1
Und berechnen uns nun die Matrix M mit diesen t-Werten:
| 0^3 0^2 0^1 1 |
M = | 0.33^3 0.33^2 0.33 1 |
| 0.66^3 0.66^2 0.66 1 |
| 1^3 1^2 1^1 1 |
Und berechnen uns nun die inverse M^-1:
| -4.5 13.5 -13.5 4.5 |
M^-1 = | 9 -22.5 18 -4.5 |
| -5.5 9 -4.5 1 |
| 1 0 0 0 |
Nun nehmen wir den P-Vektor der ersten Dimension:
Px = (5|1|4|1)
und multiplizieren ihn mit der Matrix wodurch wir
Fx = M^-1 * Px = (-58.5|90|35.5|5)
erhalten. Nun das selbe für die zweite Dimension:
Py = (3|4|2|2)
und wiederum
Fy = M^-1 * Py = (22.5|-36|12.5|3)

Somit ist unsere endgültige Formel für die Interpolation:
Ix = -58.5 * t^3 + 90 * t^2 - 35.5 * t + 5
Iy = 22.5 * t^3 - 36 * t^2 + 12.5 * t + 3

Das Ergebnis sieht nun folgendermaßen aus:

[[Bild:InterpolationBsp2.png]]

''Oben angegebenes Beispiel grafisch dargestellt. Die Punkte P0 bis P3 sind rot dargestellt. Die Kurve beinhaltet alle Punkte der gegebenen Funktionen für ( Ix , Iy ) mit t im Wertebereich [0|1].''

=Kurven mit gegebenen Tangenten=
Wir haben die oben gegebene Polynom-Gleichung für N Punkte. Wenn wir nun zusätzlich J Tangenten angeben möchten, so haben wir natürlich J zusätzliche Gleichungen und benötigen ein Polynom (N+K-1)ten Grades. Als erstes stellen wir wiederum eine derartige Polynom-Gleichung auf, jedoch mit dem Unterschied das wir dies gleich mit dem (N+J-1)ten Grad machen. Des weiteren müssen wir für jede Tangente Festlegen bei welchem t^x wir sie einbrigen möchten. Der Einfachheit halber wird hier die Reihung: zuerst die Punkte (also einem t^x mit höherem x) und danach die Tangenten (also einem t^x mit niedrigerem x als die Punkte bis hin zu x=0) verwendet. Daraus ergibt sich die allgemeine Form für die Punkte:
P0 = t(P0)^(n+J) * F(n+J) + t(P0)^(n+J-1) * F(n+J) + ... + t(P0)^(J+1) * F(J+1) + t(P0)^J * F(J) + t(P0)^(J-1) * F(J-1) + t(P0)^(J-2) * F(J-2) + ... + t(P0) * F1 + F0
P1 = t(P1)^(n+J) * F(n+J) + t(P1)^(n+J-1) * F(n+J) + ... + t(P1)^(J+1) * F(J+1) + t(P1)^J * F(J) + t(P1)^(J-1) * F(J-1) + t(P1)^(J-2) * F(J-2) + ... + t(P1) * F1 + F0
...
Pn = t(Pn)^(n+J) * F(n+J) + t(Pn)^(n+J-1) * F(n+J) + ... + t(Pn)^(J+1) * F(J+1) + t(Pn)^J * F(J) + t(Pn)^(J-1) * F(J-1) + t(Pn)^(J-2) * F(J-2) + ... + t(Pn) * F1 + F0
Wobei:
Px ... der x-te Punkt
t(Px) ... der t-Wert für den x-ten Punkt
F(n+J) bis F(J) ... der zu berechnende Faktor für den (N-1)ten Punkt
F(J-1) bis F(0) ... der zu berechnende Faktor für die J-te Tangente
Nun benötigen wir natürlich noch weitere Gleichungen für die Tangenten um das Gleichungssystem eindeutig lösbar zu machen. Eine Tangente K (hier wird bewusst K und nicht T gewählt) für den Xten Punkt lässt sich durch eine Ableitung nach t berechnen:
K(Px) = (n+J) * t(Px)^(n+J-1) * F(n+J) + (n+J-1) * t(Px)^(n+J-2) * F(n+J-1) + ... + (J+1) * t(Px)^(J) * F(J+1) + J * t(Px)^(J-1) * F(J) + (J-1) * t(Px)^(J-2) * F(J-1) + (J-2) * t(Px)^(J-3) * F(J-2) + ... + t(Px) * F2 + F1 + ( 0 * F0 )
Mit diesen Gleichungssystemen können wir wiederum eine Matrix formen, diese invertieren und los legen. Aber (meines Erachtens) erklärt sich dies am besten an einem Beispiel.

=== Hermite Kurven ===
Hermite Kurven sind Interpolationsfunktionen wo der Anfangs- und Endpunkt eine bestimmte Tangente aufweist. Üblicherweise werden Hermite Kurven zusätzlich noch auf 2 gegebene Punkte beschränkt, was wir hier der Einfachheit halber beibehalten wollen. Wir haben 2 Punkte, 2 Tangenten wodurch wir auf ein Polynom (N+J-1) = (2+2-1) = 3ten Grades kommen. Alse stellen wir eine Polynomgleichung für 2 gegebene Punkte auf, wobei der erste Punkt den Zeitpunkt 0 und der zweite Punkt den Zeitpunkt 1 erhält. Dadurch kommen wir auf zwei triviale Gleichungen:
P0 = 0 * F(3) + 0 * F(2) + 0 * F(1) + 1 * F(0)
P1 = 1 * F(3) + 1 * F(2) + 1 * F(1) + 1 * F(0)
Nun noch die Tangentengleichungen die sich aus der oben angegebenen K(Px) - Formel ergeben:
K0 = 0 * F(3) + 0 * F(2) + 1 * F(1) + 0 * F(0)
K1 = 3 * F(3) + 2 * F(2) + 1 * F(1) + 0 * F(0)
Dies ist unser lineares Gleichungssystem woraus wir wiederum unsere Matrix gewinnen:
| 0 0 0 1 |
M = | 1 1 1 1 |
| 0 0 1 0 |
| 3 2 1 0 |
Und natürlich die Formel:
W = M * F
Wobei:
W ... ein Vektor ist der die Werte P0, P1, K0, K1 (in dieser Reihenfolge) beinhaltet
M ... die oben gegebene Matrix
F ... der Vektor der die zu berechnenden Werte beinhaltet.
Diese Matrix invertiert ergibt:
| 2 -2 1 1 |
M^-1 = | -3 3 -2 -1 |
| 0 0 1 0 |
| 1 0 0 0 |
Somit können wir den F-Vektor berechnen durch
M^-1 * W = F
Wenn wir nun also für W die Werte (2,3,-1,1) hätten, wobei hier
2 ... der erste Punkt
3 ... der zweite Punkt
-1 ... die Tangente für den ersten Punkt
1 ... die Tangente für den zweiten Punkt
so ergeben sich daraus die Faktoren:
F = M^-1 * W = (-2,4,-1,2)
Wodruch wir für unsere Kurve folgende Formel erhalten:
f(t) = t^3 * (-2) + t^2 * 4 + t * (-1) + 2
Da die Dimensionen hier ebenfalls unabhängig sind, können Hermit-Kurven auf beliebig viele Dimensionen erweitert werden.

Das Ergebnis sieht nun folgendermaßen aus:

[[Bild:InterpolationBsp3.PNG]]

''Oben angegebenes Beispiel grafisch dargestellt. Die beiden Punkte sind rot dargestellt, die beiden Tangenten sind als blaue Geraden eingezeichnet. Die Kurve beinhaltet alle Punkte der gegebenen Funktionen für t im Wertebereich [0|1].''

=Tangenten von Kurven=
Besitzt man die Funktion für eine Kurve so lässt sich die Tangente durch das differenzieren dieser Funktion ermitteln. Aus unserem vorigen Beispiel wäre dies:
f(t) = t^3 * (-2) + t^2 * 4 + t * (-1) + 2
f'(t) = -6 * t^2 + 8 * t - t
Da die Dimensionen einer derartigen Kurve wie gesagt unabhängig voneinander behandelt werden können, kann man dadurch die Tangente in der entsprechenden Dimension erhalten.

= Interpolation mit anderen Funktionen =
Bisher wurden nur Interpolationen gezeigt, bei denen der t-Wert potenziert wurde. Es wurde immer ein Anfangspunkt verwendet, für den der t-Wert 0 sein sollte, und ein Endpunkt für den der t-Wert 1 sein sollte. Wir können natürlich jede beliebige Funktion für die Interpolation verwenden wo dies zutrifft. Wenn wir möchten können wir natürlich auch eine Funktion verwenden wo der Anfangspunkt bei t=X und der Endpunkt bei t=Y zu finden ist, denn eine derartige Funktion können wir wiederum umformen zu einer Funktion für die wir einen Anfangspunkt mit t=0 und einen Endpunkt mit t=1 haben.

Andere Funktionen werden meistens (nicht immer) bei nur 2 gegebenen Punkten verwendet. Hier wird meistens aus einem t-Wert im Bereich [0|1] ein neuer Wert u im Bereich [1|0] berechnet, welcher danach ähnlich wie bei der linearen Interpolation verwendet wird. Also:
u = f(t)
Interpolierter_Wert = I(t) = u * Startwert + (1-u) * Endwert
Wobei:
f(t) ... die Interpolationsfunktion, welche bei t=0 1 zurück liefert und bei t=1 0 ist.
Interpolierter_Wert ... das Ergebnis.

Mögliche andere Funktionen sind nun beispielsweise:

== Cosinus ähnliche Interpolation ==

===Cosinus Interpolation===
Der Cosinus liefert Werte zwischen -1 und 1. Wir wollen einen eindeutigen y-Wert für y=Cos(t), somit verwenden wir nur t-Werte im Wertebereich von 0 bis 180 Grad (bzw. 0 bis Pi Radianten), denn bei t=181 Grad würden wir ja den selben Wert erhalten wie für t=179 Grad.

Der t-Wert wird für den Cosinus im Wertebereich [0|Pi] bzw. [0|180Grad] benötigt. Um nun einen t-Wert (wie zuvor) im Wertebereicheich von [0|1] verwenden zu können, multiplizieren wir ihn einfach mit Pi. Also verwenden wir einfach
t2 = t * Pi
bzw. das Ganze mit Grad:
t2 = t * 180

Der Ausgabewert von Cosinus ist im Wertebereich [1|-1]. Um ihn auf den Wertebereich [1|0] zu bringen, müssen wir ihn transformieren. Dafür formen wir um:
f(t2) = Cos(t2)
g(t2) = f(t2)/2 + 1/2 = ( 1 + f(t2) ) / 2 = ( 1 + Cos(t2) ) / 2
Und nun noch t2 durch t ersetzt:
g(t) = ( 1 + Cos(t*Pi) ) / 2
bzw. das Ganze mit Grad:
g(t) = ( 1 + Cos(t*180) ) / 2

Wir haben nun eine Formel die uns bei t=0 einen Wert von 1 liefert und bei t=1 einen Wert von 0. Dies können wir in unsere allgemeine Funktion einsetzen:
Interpolierter_Wert = I(t) = g(t) * Startwert + ( 1 - g(t) ) * Endwert
Und für g(t) eingesetzt:
Interpolierter_Wert = I(t) = ( (1+Cos(t*Pi))/2 ) * Startwert + ( 1 - (1+Cos(t*Pi))/2 ) * Endwert
bzw. das Ganze mit Grad:
Interpolierter_Wert = I(t) = ( (1+Cos(t*180))/2 ) * Startwert + ( 1 - (1+Cos(t*180))/2 ) * Endwert

Nun die Frage warum der ganze Aufwand, also warum nicht linear interpolieren? Um dies zu beantworten müssen wir die Steigungen dieser Funktion betrachten, wofür wir die Ableitung der Funktion berechnen:
I'(t) = 1/2 * Endwert * Pi * Sin( t * Pi ) - 1/2 * Startwert * Pi * Sin( t * Pi )
Sieht kompliziert aus, aber wenn wir nun t=0 annehmen so erhalten wir für Sin( t * Pi ) ebenfalls 0. Wenn wir für t=1 annehmen so erhalten wir für Sin( t * Pi ) wiederum 0. Und dadurch erhalten wir an beiden Enden eine Steigung von 0.

Was können wir machen mit einer Funktion die an beiden Enden eine Steigung von 0 aufweist? Ganz einfach: wir können mehrere dieser Funktionen aneinander reihen, ohne das man einen übergang erkennt. Somit können wir sagen:
Bei t im Bereich [0|1] verwende als Startwert 3 und als Endwert 1
Bei t im Bereich ]1|2] verwende als Startwert 1 und als Endwert 7
Bei t im Bereich ]2|3] verwende als Startwert 7 und als Endwert 8
Und wenn wir alle 3 Funktionen mit dem Wertebereich [0|1] verwenden (oder mathematisch ausgedrückt: I2(t) = I(t modulo 1) ), so erhalten wir eine Kurve ohne Kanten, oder um es etwas mathematischer auszudrücken: diese Funktion ist im Wertebereich ]0|3[ ableitbar, also in diesem Wertebereich auch stetig.

Und um die Ästhetik hinter diesen Formeln zu zeigen, ein Vergleich von linearer- zu cosinus-Interpolation:

[[Bild:Interpolation.png]]

=== Quadratische Annäherung der Cosinus Interpolation ===
Da die Berechnung des Cosinus eine etwas aufwändigere Angelegenheit ist, wünscht man sich hin und wieder eine Funktion die ähnlich aussieht und die gleichen Bedingungen (also eine Steigung von 0 an Start- und Endpunkt) erfüllt. Hierfür kann man 2 quadratische Funktionen verwenden die folgendes erfüllen müssen:
#Beide Kurven müssen einen gemeinsamen Punkt besitzen, also I1(t) = I2(t) für t im Wertebereich [0|1]
#An diesem Punkt müssen beide Kurven die selbe Steigung besitzen, also es existiert ein ( I1(X) = I2(X) wo auch gilt I1'(X) = I2'(X) ).
#Steigung (also Ableitung) bei t=0 und t=1 soll 0 sein
#Die Kurve sollte symmetrisch sein bezogen auf t=0.5, so das gilt: I1(t) = 1-I2(1-t). Somit muss gleichzeitig der Punkt wo gilt I1(t) = I2(t) bei 0.5 liegen.

Wir können uns nun aus der ersten und dritten Bedinung einfach die beiden Formeln herleiten, aber um es kurz zu machen:
Wenn t <= 0.5 dann I1(t) = -2*t^2 + 1
Wenn t > 0.5 dann I2(t) = 2*t^2 - 4*t + 2 = 2 * (1-t)^2
Nun zeigen wir, dass die oben angegebenen Bedingungen erfüllt sind:
#I1(0.5) = -2*0.5^2 + 1 = 0.5; I2(0.5) = 2 * (1-0.5)^2) = 0.5
#I1'(t) = -4t, I1'(0.5) = -2; I2'(t) = 4*t - 4, I2'(0.5) = -2
#I1'(0) = -4*0 = 0; I2'(1) = 4*1 - 4) = 0
#I1(t) = 1-I2(1-t) '''=>''' -2*t^2 + 1 = 1 - (2*(1-t)^2 - 4*(1-t) + 2) '''=>''' -2*t^2 + 1 = 1 - (2 - 4*t + 2*t^2 - 4 + 4*t + 2) '''=>''' -2*t^2 + 1 = -2*t^2 + 1

=== Cosinus ähnliche Interpolation durch Polynominterpolation ===
Wenn wir eine Polynominterpolation mit den beiden Endtangenten 0 berechnen wollen, so verwenden wir eine Hermite Kurve. Hierbei verwenden wir die Werte:
1 ... Startpunkt
0 ... Endpunkt
0 ... Steigung bei Startpunkt
0 ... Steigung bei Endpunkt
Mit der unter Hermit Kurven angegebenen Matrix M^-1 können wir uns nun die dazugehörige Funktion berechnen und erhalten:
I(t) = 2*t^3 - 3*t^2 + 1
Die ersten beiden Bedingungen von vorher sind automatisch erfüllt, da es sich nur um eine Funktion handelt. Für die 3. und 4. Bedingung lässt sich ebenfalls verhältnismäßig einfach zeigen das sie erfüllt sind.

=== Vergleich der Cosinus ähnlichen Interpolationsarten ===
Und zu guter letzt hier noch die grafische Veranschaulichung der etwas zahlenbeladenen Funktionen.

[[Bild:InterpolationCosAnnaeherung.png]]

''Die 3 Cosinus ähnlichen Funktionen graphisch dargestellt:
*Grün: Cos-Interpolation
*Rot: Polynom-Interpolation
*Blau: Quadratische Annäherung''

=Interpolierte Flächen=
Bisher wurden ausschließlich Kurven betrachtet. Aus Kurven lassen sich jedoch ohne größere Umstände auch Flächen bilden. Hier hat man zwei (unterschiedliche) t-Werte und eine Matrix von Punkten gegeben, wobei jeder Punkt gegebenenfalls noch 1 oder 2 Tangenten besitzen kann. Um einen Punkt einer Fläche zu berechnen interpoliert man zuerst die Punkte für jede Zeile der Punktmatrix. Nachdem man nun die interpolierten Punkte für jede Zeile besitzt kann man sich mit diesen Punkten ein neues Gleichungssystem aufstellen und wiederum eine Kurve bilden. Diese Kurve interpoliert man wiederum mit dem zweiten gegebenen t-Wert. Dies lässt sich auf beliebig viele Dimensionen nach dem gleichen Schema erweitern, üblicherweise wird dies jedoch nur für Oberflächen (also 2D) benötigt.

==Normalvektoren==
Besitzt man Flächen und berechnet sie nach dem gegebenen Schema, so berechnet man sich zuerst auch mehrere Kurven von denen man die Tangenten berechnen kann. Interpoliert man nun diese Tangenten mit der gleichen Kurvenfunktion wie die resultierenden Punkte, und berechnet sich aus der resultierenden Kurvenfunktion ebenfalls die Tangente, so erhält man 2 Tangenten. Aus diesen beiden Tangenten kann nun mit einem Kreuzprodukt ein Normalvektor errechnet werden. 
'''ACHTUNG: auf Richtigkeit überprüfen'''

=Kurvenlängen-Interpolation=
Es könnte erwünscht sein (beispielsweise für Kamerafahrten, Keyframe Interpolationen jeglicher Art oder auch bei der Interpolation von Positionsangaben die man beispielsweise über ein Netzwerk erhält), dass man über keine fixe Achse t interpolieren möchte, sondern über die Kurvenlänge.

Bei den typischen physikalischen Beispielen besitzt man meist eine Geschwindigkeit welche durch Beschleunigung verändert wird. Also wenn man einen Ball senkrecht hoch wirft, so gibt es einen Punkt an dem er komplett stehen bleibt. Für diese Art von physikalischen Berechnungen wird man also kaum eine Kurvenlängen-Interpolation benötigen.

Wenn man jedoch sehr langsame Geschwindigkeiten besitzt, also beispielsweise zu fuß geht, so haben wir eine nahezu konstante Gehgeschwindigkeit, egal ob wir eine Kurve gehen oder nicht. Wenn wir noch weiter gehen und auf einer Straße oder einer Rennstrecke alle 100 Meter ein Längenangabenschild hin stellen möchten, so ist uns Beschleunigung und auch die Geschwindigkeit vollkommen egal. Wir hätten also am liebsten eine Funktion P(s), welche uns den Punkt der Kurve für für Kilometer (oder Meter) s liefert.

==Der eindimensionale Fall==
Dieser Teil soll lediglich als Erklärung dienen, besitzt in der Praxis aber kaum Relevanz.

Im Eindimensionalen Fall kann man sich dies noch sehr gut veranschaulichen. Wenn ich eine gerade Strecke besitze und meine 1D-Koordinaten kenne, so kann ich ganz einfach sagen: zum Zeitpunkt t bin ich Betrag( f(t) - f(t0) ) Meter (allg. Einheiten) gegangen. Interessant wir es noch mal wenn ich die Richtung ändere, also wenn ich bei Kilometer 4 merke das ich etwas zu Hause vergessen habe, noch einmal umdrehe und dann weiter fahre. In diesem Fall kann ich nicht sagen: ich befinde mich an Position 10 Kilometer entfernt => ich bin 10 Kilometer gegangen, sondern in Wirklichkeit habe ich noch zusätzlich 8 Kilometer umweg hinter mir.

Dieses simple beispiel mathematisch ausgedrückt:

wenn f(t) monoton steigend oder monoton fallend ist: Kurvenlänge(t) = | f(t) - f(t0) |
Sonnst: Kurvenlänge = Integral[t0 bis t]( f'(t) )
Beim Integrieren müssen wir nun aufpassen, ob unsere Stammfunktion 0-Stellen besitzt. Bei jeder solchen 0-Stelle Zx zerteilen wir die Wertebereiche:
W = [t0, Z1, Z2, Z3, ..., Zn, t]

Kurvenlänge(t) = Summe[ n=1 bis Elemente von W ]( Integral[W[n-1] bis W[n]]( f'(t) )
Da wir nun in der Stammfunktion alle 0-Stellen berücksichtigt haben können wir das Integral "kürzen", also
Kurvenlänge(t) = Summe[ n=1 bis Elemente von W ]( | f(w[n]) - f(w[n-1]) | )

Das Integral macht hier also nichts anderes als Richtungswechsel zu erkennen, denn bei einem Richtungswechsel in 1D ändert sich das Vorzeichen der Ableitung einer Funktion, und für jeden Vorzeichenwechsel muss es auch einen 0-Punkt geben wenn es sich um eine stetige Funktion handelt.

Wir kennen nun also den Weg den wir zu einem bestimmten Zeitpunkt zurückgelegt haben. Wir wollen jedoch den Zeitpunkt wissen an dem wir eine bestimmte Weglänge zurückgelegt haben, um die Funktion f(t) durch f(t(s)) = g(s) wodurch g(s) eine Funktion ist wo wir die Position für einen bestimmte Kurvenlänge erhalten.

Wir müssen also ein t finden für das gilt
Kurvenlänge(t) = s
und können danach dieses t in unsere Ursprüngliche Kurvengleichung einsetzen.

Und nun mit voller Wucht: warum bringt uns das alles ganz und gar nichts?
Wenn wir eine Eindimensionale "Kurve" besitzen und wir wollen diese über die Kurvenlänge parametrisieren, so sagen wir schlicht und ergreifend:
x = x0 +/- s
wenn wir nicht mehrere Fälle besitzen. Wenn wir Fallunterscheidungen bekommen, so gibt es (wie im mehrdimensionalen Fall noch verdeutlicht wird) natürlich auch Methoden mit denen wir diese Fallunterscheidungen umgehen können (namentlich: numerische Integration). Dennoch ist die Funktion wohl in nahezu allen Fällen einfacher mit derartigen Fallunterscheidungen zu berechnen.

===Beispiel===
Ein Beispiel noch am Rande, wie man unschwer erahnen kann, gibt es eher wenig alltäglichere Beispiele die nicht zu trivial und von Interesse wären:

Wir besitzen eine gedämpfte Schwingung mit der Formel
f(t) = e^(-t) * sin(t)
und möchten aus unerfindlichen Gründen wissen wo sich der schwingende Körper befindet wenn er den Weg s zurückgelegt hat.

Wir berechnen uns die Ableitung
f'(t) = e^(-t) * cos(t) - e^(-t) * sin(t)
und nun die 0-Stellen, also
f'(t) = 0
davon gibt es aber natürlich jede Menge ... aber wir begnügen und mit den ersten 3:
f'(PI/4) = 0 | f(PI/4) ~= 0.322
f'(~3.927) = 0 | f(3.927) ~= -0.014
f'(~7.069) = 0 | f(7.069) ~= 0.0006
Da der Startpunkt (t=0) natürlich auch bei 0 liegt, erhalten wir also jetzt für unsere Position in Abhängigkeit der Weglänge s:
g(s) = s für s im Bereich [0,0.322]
g(s) = 2*0.322-s für s im Bereich ]0.322|0.658] wobei 0.658 = 0.322 + | 0.322-0.014 |
g(s) = s-2*0.322-2*0.014 für s im Bereich ]0.658|0.6585] wobei 0.6586 = 0.322 + | 0.322 - (-0.014) | + | -0.014 - 0.0006 |

==Kurven in höheren Dimensionen==
Im allgemeinen Fall kann eine Kurve in einer bestimmten Dimension als Vektor von Funktionen dargestellt werden:
| x(t) |
P(t) = | y(t) |
| z(t) |
| ... |
wir können die Tangente berechnen indem wir in jeder Dimensionen die Funktion ableiten:
| x'(t) |
T(t) = | y'(t) |
| z'(t) |
| ... |
und natürlich handelt es sich nun nicht um irgendeine Tangente, sondern um die Tangente welche auch die Änderungsgeschwindigkeit der Kurve abhängig von t beschreibt. Wir können die Länge dieser Tangente also als Geschwindigkeit der Kurve betrachten. Die Länge eines Vektors ist ein skalarer Wert, also erhalten wir für die Geschwindigkeit zu einem Zeitpunkt t die Funktion:
Geschwindigkeit(t) = | T(t) |
Der Betrag der Tangente wir nun folgendermaßen gebildet:
Geschwindigkeit(t) = Wurzel( x'(t)^2 + y'(t)^2 + z'(t)^2 + ... )
Nun besitzen wir eine Funktion für die Geschwindigkeit der Kurve welche uns integriert die Länge der Kurve bis zum Zeitpunkt t angibt. Im Gegensatz zum eindimensionalen Fall (wo dies eher wenig Sinn hatte) quadrieren wir hier jeden verwendeten Wert, wodurch diese Funktion niemals < 0 werden kann, somit müssen wir beim integrieren auch nicht auf 0-Stellen aufpassen.

Wir Integrieren nun:
Kurvenlänge(t) = Integral[t0 bis t]( Geschwindigkeit(t) )

Und hier stoßen wir an einen unangenehmen Punkt. Nehmen wir ein "einfaches" Polynom für x(t), y(t) und z(t). An einem Integral wie aus unserem Polynom-Beispiel:
Integral[t0 bis t]( Wurzel( (-58.5*t^3 + 90*t^2 - 35.5*t + 5)^2 + (22.5*t^3 - 36*t^2 + 12.5*t + 3)^2 ) )
scheitern sogar gute Mathematik-Bibliotheken, und von normalsterblichen Menschen ganz zu schweigen.

Doch noch ist nicht alles Verloren, wir können uns der Lösung recht gut annähern. Bestimmte Integrale können wir mit numerischen Verfahren lösen, wodurch es zumindest möglich ist ein entsprechendes t anzunähern und mit entsprechenden Näherungsverfahren können wir uns auch verhältnismäßig schnell und gut annähern.

===Numerische Integration===
Da dieser Teil wohl etwas zu ausschweifend wäre möchte ich hier nur die Grundlegende Idee und eine sehr einfache Methode erwähnen.

Bei numerischen Verfahren wählt man üblicherweise ein paar Punkte der zu integrierenden Funktion aus und berechnet den Flächeninhalt des Kurvenstückes indem man häufig sehr grobe Annäherungen verwendet. Die wohl naivste Methode ist, wenn man sagt:
Integral[a bis b]( f(x) ) ~= | (b-a) * f( (b+a)/2 ) |
Also man berechnet sich den Flächeninhalt des Rechtecks, mit der Breite des entsprechenden Kurvenstückes und einem Punkt der Kurve (in diesem Fall der Punkt in der Mitte des Stückes).

Eine andere sehr bekannte Methode verwendet statt Rechtecken Trapeze und benötigt dafür natürlich bereits 2 Punkte der Kurve:
Integral[a bis b]( f(x) ) ~= | (b-a) * ( f(a) + f(b) )/2 |

Da eine solche Annäherung natürlich erfolgversprechender wird, desto kleiner der Abstand zwischen a und b ist, wird man üblicherweise einen größeren Bereich in mehrere (oder sogar sehr viele) kleinere Bereiche unterteilen:
Integral[a bis b]( f(x) ) = Integral[a bis k1]( f(x) ) + Integral[k1 bis k2]( f(x) ) + ... + Integral[kn bis b]( f(x) )
Je kleiner die Teilbereiche werden, umso genauer wird das Ergebnis.

Generell kann man wohl sagen, dass bei komplexeren Integralen ein guter Mittelweg zu finden ist zwischen Genauigkeit und Rechenaufwand, sofwohl was die Anzahl der Teilstücke, als auch die Qualität der Berechnung der Teilstücke betrifft.

===Näherungsverfahren===
Auch hier gibt es mehrere Varianten, da es sich jedoch um eine monoton wachsende Funktion handelt, sind wohl alle Varianten brauchbar, wenn einige davon aber dennoch endlos um das Ziel herum oszillieren können. Wir besitzen nun eine Methode mit der wir beispielsweise das oben problematische Integral ganz gut annähern können. Wir können also jetzt bestimmten:
Im Zeitraum t0 bis t hat die Kurve eine Länge s.
Wir möchten aber nun für einen Länge s einen Zeitpunkt t (in Abhängigkeit von t0) finden. Dies erreichen wir, indem wir uns möglichst schnell an dieses t annähern. Ein Beispiel dafür ist das Newtonsche Näherungsverfahren. Wiederum soll jedoch nur ein grober Überblick über die Materie gegeben werden.

Wenn wir einen Zielwert (der Einfachheit halber immer f(x) = 0 ) besitzen, einen aktuellen Wert X1 und f(X1) = k, so wissen wir bei einer monoton steigenden Funktion bereits ob wir nach links oder nach rechts müssen. Ist k größer als 0 so müssen wir nach links. Ist k kleiner 0, so müssen wir nach rechts. Des weiteren können wir uns noch die Steigung der Funktion am Punkt X1 berechnen, wodurch wir auch eine recht gute Ahnung davon bekommen wie weit wir uns bewegen sollen. Dafür nehmen wir an, dass die Steigung annähernd gleich bleibt. Nun berechnen wir uns wie weit wir bei gleich bleibender Steigung gehen müssen und erhalten so unser X2. Diesen Vorgang wiederholen wir so lange bis wir einen genügend genauen Wert besitzen, oder der Wert längere Zeit nicht mehr genauer wird. Die Formel dafür lautet:
X(n+1) = Xn - f(Xn) / f'(Xn)
Und somit haben wir alle Werkzeuge zur Verfügung die wir benötigen, denn nun können wir den 0-Punkt der Funktion
Integral[t0 bis t]( f(x) ) - s = 0
annähern, so dass wir ein t erhalten welches die gesuchte Weglänge gut annähert. Diese t können wir danach in unsere Formel ganz normal einsetzen und somit erhalten wir die Position und bei Bedarf natürlich auch wieder die Tangente oder einen Normalvektor.

===Beispiel===
Wir verwenden hier wieder eine Kurve im 2D-Raum welches wie unter "Polynome höheren Grades" aus 4 Punkten erstellt wurde. Ohne große Umschweife hier die beiden Formeln:
Ix = -31.5*t^3 + 58.5*t^2 - 28*t + 5
Iy = 22.5*t^3 - 36*t^2 + 12.5*t + 3

Wir implementieren diese direkt (also hardgecodet) um den Quellcode eher kurz und einfach zu halten (bisher C-Code):
/* x Wert der Kurve in Abhängigkeit der Zeit */
double func_x( double t )
{
return 5.0 - 28.0*t + 58.5*t*t - 31.5*t*t*t;
}

/* func_x'(t) also func_x abgeleitet. Ein Polynom lässt sich sehr einfach
* ableiten, der Einfachheit halber jedoch auch hier direkt angegeben.
*/
double func_dx( double t )
{
return -28.0 + 117.0*t - 94.5*t*t;
}

/* y Wert der Kurve in Abhängigkeit der Zeit */
double func_y( double t )
{
return 3.0 + 12.5*t - 36.0*t*t + 22.5*t*t*t;
}

/* func_y'(t) also func_y abgeleitet */
double func_dy( double t )
{
return 12.5 - 72.0*t + 67.5*t*t;
}

/* Weg in Abhängigkeit der Zeit abgeleitet. */
double func_ds( double t )
{
return sqrt( func_dx(t)*func_dx(t) + func_dy(t)*func_dy(t) );
}

Nun der erste etwas interessantere Teil, das numerische integrieren von func_ds:
/* Liefert eine Annäherung an das Integral von func mit den Schranken a und b.
* Parameter:
* a: untere Schranke
* b: obere Schranke
* sections: Anzahl der verwendeten Trapeze zur Annäherung, je höher desto genauer die Annäherung
* Wenn b kleiner als a ist, so wird ein negativer Wert zurück gegeben.
*/
double NIntegrate( double a, double b, int sections )
{
int d;
double sum = 0.0;
double pos = a;
double pos2 = a + (b-a)/(double)sections;
double f = func_ds( pos );
double f2;

for( d=0; d<sections; d++ )
{
f2 = func_ds( pos2 );

sum += fabs( (f+f2)*0.5*(b-a)/(double)sections );

pos = pos2;
pos2 += (b-a)/(double)sections;

f = f2;
}

// Ist die untere Schranke a größer als die obere Schranke b, so negiere den Wert
if( a > b )
return -sum;
else
return sum;
}
Mit dieser Funktion können wir uns nun bereits berechnen wie viel Weg zu einem Zeitpunkt t zurück gelegt wurde. Ein Beispiel hierfür folgt noch weiter unten. Um uns für einen gegebenen Weg s an einen Zeitpunkt t anzunähern an dem wir den Weg zurück gelegt haben, verwenden wir nun ein Näherungsverfahren. Wir wollen die Funktion
f(x) = Integral[0 bis t]( func_ds(x) ) - s
an 0 annähern. Für das Newton-Verfahren benötigen wir noch die Ableitung von f(x):
f'(x) = func_ds(x)
und nun können wir folgende Formel verwenden:
Xn+1 = Xn - (Integral[ 0 bis Xn ]( func_ds(x) ) - s) / func_ds(Xn)
Und genau das machen wir in folgender Funktion:
/* Nähert den Wert t für
* Integral[0 bis t]( func_ds(x) ) = Value
* an.
* Parameter:
* start: ein möglichst genau geschätzter Wert mit dem die Annäherung begonnen werden soll.
* Value: Zielwert nach obiger Formel.
* depth: Anzahl der Iterationen (bzw. um genau zu sein der Rekursionen) je höher dieser Wert desto genauer das Ergebnis
* sections: Wird an NIntegrate weitergereicht, je höher dieser Wert desto genauer das Ergebnis
*/
double FindValue( double start, double Value, int depth, int sections )
{
double newval;
double f = func_ds( start );

if( depth <= 0 )
return start;

// verhindert Division durch 0. Extrem kleine Werte _könnten_ auch problematisch sein.
if( f < 0.0000001 && f > -0.0000001)
{
if( f >= 0.0f )
newval = start - (NIntegrate( 0.0, start, sections ) - Value);
else
newval = start + (NIntegrate( 0.0, start, sections ) - Value);
}
else
{
// die Unterscheidung ob start > 0 ist wird bereits von NIntegrate durchgeführt
newval = start - (NIntegrate( 0.0, start, sections ) - Value) / f;
}

return FindValue( newval, Value, --depth, sections );
}
Nun noch das ein oder andere Beispiel wie wir diese Funktionen verwenden:
/* Beispielshafte Verwendung der Funktionen */
void main()
{
double FullKurveLength = NIntegrate( 0.0, 1.0, 100 );
double TforS;
double KurveLength;

printf( "Die gesamte Kurvenlaenge (von Zeitpunkt 0 bis 1) betraegt ziemlich genau: %f\n", FullKurveLength );

printf( "\n" );

/* Parameter:
* a = 0.0: Wir möchten den zurückgelegten Weg angefangen von Zeitpunkt 0.0
* b = 0.5: Wir möchten den zurückgelegten Weg bis zum Zeitpunkt 0.5, also von 0.0 bis 0.5
* sections = 10: liefert wahrscheinlich ein eher ungenaues Ergebnis.
*/
KurveLength = NIntegrate( 0.0, 0.5, 10 );
printf( "Ungeneau: in der haelfte der Zeit wurde %f Weg zurueck gelegt.\n", KurveLength );

KurveLength = NIntegrate( 0.0, 0.5, 20 );
printf( "Etwas geneauer: in der haelfte der Zeit wurde %f Weg zurueck gelegt.\n", KurveLength );

KurveLength = NIntegrate( 0.0, 0.5, 100 );
printf( "Recht geneau: in der haelfte der Zeit wurde %f Weg zurueck gelegt.\n", KurveLength );

printf( "\n" );

/* Parameter:
* start = 0.5: wir schätzen das der halbe Weg zum Zeitpunkt 0.5 zurück gelegt wurde
* Value = FullKurveLength * 0.5: wir möchten wissen zu welchem Zeitpunkt der halbe Weg zurück gelegt wurde
* depth & sections = 0: liefert wahrscheinlich ein eher ungenaues Ergebnis.
*/
TforS = FindValue( 0.5, FullKurveLength * 0.5, 5, 10 );
printf( "Ungenau: zum Zeitpunkt %f wurde der halbe Weg zurueck gelegt.\n", TforS );

TforS = FindValue( 0.5, FullKurveLength * 0.5, 10, 20 );
printf( "Etwas genauer: zum Zeitpunkt %f wurde der halbe Weg zurueck gelegt.\n", TforS );

TforS = FindValue( 0.5, FullKurveLength * 0.5, 50, 100 );
printf( "Recht genau: zum Zeitpunkt %f wurde der halbe Weg zurueck gelegt.\n", TforS );
};
Als ausgabe dieses Tests erhalten wir:
Die gesamte Kurvenlaenge (von Zeitpunkt 0 bis 1) betraegt ziemlich genau: 9.201214

Ungeneau: in der haelfte der Zeit wurde 5.582572 Weg zurueck gelegt.
Etwas geneauer: in der haelfte der Zeit wurde 5.558352 Weg zurueck gelegt.
Recht geneau: in der haelfte der Zeit wurde 5.550576 Weg zurueck gelegt.

Ungenau: zum Zeitpunkt 0.376217 wurde der halbe Weg zurueck gelegt.
Etwas genauer: zum Zeitpunkt 0.378924 wurde der halbe Weg zurueck gelegt.
Recht genau: zum Zeitpunkt 0.379795 wurde der halbe Weg zurueck gelegt.
Wir können uns nun auch die Zeitpunkte ausrechnen an denen 10%, 20%, ... des Weges zurück gelegt wurde und uns die Punkte auf der Kurve einzeichnen um auch einen visuelleren Vergleich zu erhalten:

[[Bild:KurvenlaengenInterpolation.gif]]

Rot: Die Punkte zu den Zeitpunkten 0.0, 0.1, 0.2, ..., 0.9, 1.0

Blau: Die Punkte zu denen 0%, 10%, 20%, ..., 90%, 100% des Weges zurück gelegt wurde angenähert durch FindValue(...) mit depth = 5 und sections = 10

Grün: Die Punkte zu denen 0%, 10%, 20%, ..., 90%, 100% des Weges zurück gelegt wurde angenähert durch FindValue(...) mit depth = 50 und sections = 100

Gut zu erkennen ist auf diesem Bild auch, dass 10 Unterteilungen für einen das Integrieren von 0 bis 0.1 noch ganz gute Ergebnisse liefert, jedoch bei einem Wertebereich von 0 bis 1 schon ziemlich ungenau wird, somit macht es durchaus Sinn die Anzahl der Unterteilungen auch abhängig von der Größe des Bereiches zu machen.

Datei:KurvenlaengenInterpolation.gif

2006-06-17T17:04:00Z

Lyr: Vergleich Kurvenlängeninterpolation und Interpolation über die Zeit. Rot: Die Punkte zu den Zeitpunkten 0.0, 0.1, 0.2, ..., 0.9, 1.0 Blau: Die Punkte zu denen 0%, 10%, 20%, ..., 90%, 100% des Weges zurück gelegt wurde angenähert durch FindValue(...)

Vergleich Kurvenlängeninterpolation und Interpolation über die Zeit.

Rot: Die Punkte zu den Zeitpunkten 0.0, 0.1, 0.2, ..., 0.9, 1.0

Blau: Die Punkte zu denen 0%, 10%, 20%, ..., 90%, 100% des Weges zurück gelegt wurde angenähert durch FindValue(...) mit depth = 5 und sections = 10

Grün: Die Punkte zu denen 0%, 10%, 20%, ..., 90%, 100% des Weges zurück gelegt wurde angenähert durch FindValue(...) mit depth = 50 und sections = 100

Kategorie Diskussion:Exzellent

2006-06-15T05:02:41Z

Lyr: /* Kandidatenliste */

OpenGL Smooth

2006-05-21T06:25:10Z

Lyr:

[[OpenGL]] besitzt eine weitere Möglichkeit Kanten-Antialiasing zu realisieren. Diese können mit [[glEnable]] mit den Parametern GL_POINT_SMOOTH, GL_LINE_SMOOTH bzw. GL_POLYGON_SMOOTH aktiviert werden.

=Technik=
Wenn der Smooth-Wert für ein [[Primitive]] aktiviert ist, so werden im Fall von Punkten und Linien bereits andere Pixel vom [[Rasterisierung|Rasterizer]] generiert. Zusätzlich wird für jedes generierte [[Fragment]] noch ein Deckungs-Wert berechnet, welcher angibt wie viel Prozent des Fragmentes von dem entsprechenden [[Primitive]] bedeckt werden.

Dieser Deckungs-Wert wird nach allen anderen Berechnungen mit dem Alpha-Wert des Fragmentes multipliziert. Aus diesem Grund hängt diese Art von Antialiasing auch mit [[Blending]] zusammen, wodurch das Zeichnen üblicherweise mit Tiefensortierung erfolgen muss (was gleichzeitig der größte Nachteil an dieser Methode ist).

==Punkte==
Werden (größere) Punkte mit aktiviertem GL_POINT_SMOOTH gerendert, so wird offensichtlich aus dem Quadrat ein richtiger Kreis. Auch ohne aktiviertem [[Blending]] (mittels [[glEnable]]( GL_BLEND ) ) hätte man hier also bereits ein Kreisform, aber natürlich ohne geglätteten Rand.

[[Bild:GL_POINT_SMOOTH_deaktiviert.png]] [[Bild:GL_POINT_SMOOTH_aktiviert.png]]

''4-Fach vergrößterter Punkt links ohne und recht mit GL_POINT_SMOOTH.''

==Linien==
Werden Linien mit aktiviertem GL_LINE_SMOOTH gerendert, so wird offensichtlich aus dem Trapez (mehrere 1-Pixel Linien entweder nebeneinander oder übereinander) ein Quader. Dies hat (vor allem bei breiteren Linien) ebenfalls auch Auswirkungen wenn [[Blending]] deaktiviert ist.

[[Bild:GL_LINE_SMOOTH_deaktiviert.png]] [[Bild:GL_LINE_SMOOTH_aktiviert.png]]

''4-Fach vergrößterte Linie links ohne und recht mit GL_LINE_SMOOTH.''

==Polygone==
Polygone (also Triangles, Quads, Triangle-Strips, Triangle-Fans und Polygone) verändern ihr Erscheinungsbild mit deaktivierten [[Blending]] kaum. Mit aktiviertem [[Blending]] werden aber natürlich die Kanten geglättet.

=Probleme=
Bei Polygonen tauchen die größten Problem auf, und zwar so große, dass es von vielen Grafikkarten gar nicht unterstützt wird. Vor allem bei aktiviertem GL_POLYGON_SMOOTH kommt es also des öfteren vor, dass in den Softwaremodus umgeschalten wird, und nicht einmal dann kann man sicher sein dass es funktioniert. Und wenn es doch funktioniert so erwartet einem häufig bereits die nächste Überraschung.

Das Problem ist, dass zwei aneinanderliegende Dreiecke häufig einen Spalt aufweisen. Da die [[Primitive]]n GL_QUADS, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN und GL_POLYGON üblicherweise ebenfalls in Dreiecke aufgeteilt werden, entsteht dieser Spalt auch dort. Und wäre dies nicht schon genug so kann ein einzelnes Dreieck an einer [[Clipping Plane]] oder dem [[Frustum]] ebenfalls noch in 4 kleiner Dreiecke aufgesplittet werden, wo wir wiederum diesen Spalt antreffen.

Also GL_POLYGON_SMOOTH ist mit äusserster Vorsicht zu geniesen.

=OpenGL Funktionen=
*[[glEnable]] um GL_POINT_SMOOTH, GL_LINE_SMOOTH bzw. GL_POLYGON_SMOOTH zu aktivieren.
*[[glHint]] um den [[OpenGL]]-Treiber zu bitten eine schnellere oder eine schönere Berechnungsmethode zu verwenden.

glEnable

2006-05-21T06:19:21Z

Lyr: /* GL_LINE_SMOOTH */

= glEnable, glDisable =

== Name ==
'''gEnable, glDisable''' - Aktiviert bzw. deaktiviert eine server-seitige Fähigkeit.

== Delphi-Spezifikation ==
procedure '''glEnable'''(''cap'' : TGLEnum); 
procedure '''glDisable'''(''cap'' : TGLEnum);

== Parameter ==
<table border=1 rules=all>
<tr>
<td>''cap''</td>
<td>Symbolische Konstante der zu (de)aktivierenden GL-Fähigkeit.</td>
</tr>
</table>

== Beschreibung ==
'''glEnable''' und '''glDisable''' aktivieren bzw. deaktivieren verschiedene Fähigkeiten, deren momentane Einstellung entweder mit [[glIsEnabled]] oder [[glGet]] ermittelt werden kann. Die Vorgabe für alle Einstellungen (Ausgenommen GL_DITHER und GL_FALSE, die beide GL_TRUE sind) ist GL_FALSE.

Beide Befehle bekommen als Argument die symbolische Konstante der OpenGL-Fähigkeit übergeben die umgeschaltet werden soll. Gültig sind dabei folgende Werte :

=== GL_ALPHA_TEST ===
Wenn aktiviert, wird der Alphatest ausgeführt. Siehe [[glAlphaFunc]].

=== GL_AUTO_NORMAL ===
Wenn aktiviert, werden automatisch Normalen generiert wenn [[GL_MAP2_VERTEX_3]] oder [[GL_MAP2_VERTEX_4]] zur Erstellung von Vertices genutzt werden. Siehe [[glMap2]].

=== GL_BLEND ===
Wenn aktiviert werden ankommenden RGBA-Farben mit den Werten die sich im Farbpuffer befinden vermischt. Siehe [[glBlendFunc]].

=== GL_CLIP_PLANEi ===
Wenn aktiviert, wird die Geometrie gegen die nutzerdefinierte Schnittfläche ''i'' geschnitten. Siehe [[glClipPlane]].

=== GL_COLOR_LOGIC_OP ===
Wenn aktiviert, werden die momentan gewählten logischen Operationen auf ankommenden RGBA-Farben und Farbpuffer-Werte angewendet. Siehe [[glLogicOp]].

=== GL_COLOR_MATERIAL ===
Wenn aktiviert, benutzen einer oder mehrere Materialparameter die aktuelle Farbeinstellung. Siehe [[glColorMaterial]].

=== GL_COLOR_TABLE_EXT ===
Wenn aktiviert, werden Farbbild-Komponenenten auf eine Farbtabelle verteilt die vor einer Windiung stattfindet. Siehe [[glColorTableEXT]].

=== GL_CONVOLUTION_1D_EXT ===
Wenn aktiviert, wird die ein-dimensionale Windung während des Pixeltransfers durchgeführt. Siehe [[glConvolutionFilter1DEXT]].

=== GL_CONVOLUTION_2D_EXT ===
Wenn aktiviert, wird die zwei-dimensionale Windung während des Pixeltransfers durchgeführt. Siehe [[glConvolutionFilter2DEXT]].

=== GL_CULL_FACE ===
Wenn aktiviert, werden Polygone entsprechend ihrer Zeichnungsrichtung (Wicklung wäre der korrekt Ausdruck --[[Benutzer:Sascha Willems|Sascha Willems]] 13:05, 9. Jul 2004 (CEST)) (in Fensterkoordinaten) ausgeschlossen. Siehe [[glCullFace]].

=== GL_DEPTH_TEST ===
Wenn aktiviert werden Tiefenvergleiche getätigt und der Tiefenpuffer aktualisiert. Man beachte das selbst dann, wenn ein Tiefenpuffer existiert und die Tiefenmaske ungleich null ist, der Tiefenpuffer nicht aktiviert wird wenn der Teifentest inaktiv ist. Siehe [[glDepthFunc]] und [[glDepthRange]].

=== GL_DITHER ===
Wenn aktiviert, werden Farbkomponenten oder -indizes gedithert (siehe [[Dithering]])

=== GL_FOG ===
Wenn aktiviert, wird die Nebelfarbe in den Farbwert nach der Texturierung gemischt. Siehe [[glFog]].

=== GL_FOG_OFFSET_EXT ===
Wenn aktiviert wird ein Versatz zum Z-Wert, der zur Berechnung des Nebels genutzt wird, addiert. Siehe [[glFog]].

=== GL_INDEX_LOGIC_OP ===
Wenn aktiviert, werden die momentan gewählten logischen Operationen auf einkommende Index- und Farbpufferindizes angewandt. Siehe [[glLogicOp]].

=== GL_INTERLACE_EXT ===
Wenn aktiviert, wird ein Bild als interlaced (zu Deutsch : verschachtelt) angesehen. Jede Reihe ''m'' des Bildes wird behandelt als wäre sie Reihe 2 * ''m''. Wenn das Quellbild also eine Höhe von ''h'' Reihen hat, erweitert dies die Höhe des Bildes effektiv auf 2 * ''h'' - 1. Wo Fehler durch die Angabe ungültiger Bilddimensionen entstehen (z.B. [[glTexImage2D]], wird die resultierende Dimension geprüft, nicht die Dimension des Quellbildes. Dieses Token hat keinen Effekt auf Bild-Leseoperationen (Siehe [[GL_INTERLACE_READ_I3D]].

=== GL_INTERLACE_READ_I3D ===
Wenn aktiviert, werden Bilder im Framepuffer als interlaced angesehen. Jede Reihe ''m'' des Bildes wird behandelt als wäre sie Reihe 2 * ''m''. Wenn das Bild im Framepuffer eine Höhe von ''h'' Reiehen hat, wird dieses effektiv auf eine Höhe von 2 * ''h'' - 1 vergrößert. Dieses Token betrifft nur [[glReadPixels]] und [[glCopyPixels]].

=== GL_LIGHTi ===
Wenn aktiviert, wird die Lichtquelle ''i'' in die Berechnung der Beleuchtungsgleichung mit einbezogen. Siehe [[glLightModel]] und [[glLight]].

=== GL_LIGHTING ===
Wenn aktiviert, werden die aktuellen Beleuchtungsparameter genutzt um die Vertex- oder Indexfarbe zu berechnen. Ansonsten wird einfach die aktuelle Farbe zw. der aktuelle Index zugewiesen. Siehe [[glMaterial]], [[glLightModel]] und [[glLight]].

=== GL_LINE_SMOOTH ===
Wenn aktiviert, werden Linien mit dem korrekten rechtwinkligen "Eecken" gerendert. Dieser Effekt ist nur bei [[glLineWidth|breiten Linen]] von Bedeutung.
{|
! Aktiviert
! Deaktiviert
|-
|[[Bild:GL LINE SMOOTH_aktiviert.png]]
|[[Bild:GL LINE SMOOTH deaktiviert.png]]
|}
''In vierfacher Vergrößerung''

=== GL_LINE_STIPPLE ===
Wenn aktiviert, wird das aktuelle Punktierungsmuster für das Zeichnen von Linien verwendet. Siehe [[glLineStipple]].

=== GL_MAP1_COLOR_4 ===
Wenn aktiviert, generieren Aufrufe an [[glEvalCoord1]], [[glEvalMesh1]] und [[glEvalPoint1]] RGBA-Werte. Siehe [[glMap1]].

=== GL_MAP1_INDEX ===
Wenn aktiviert, generieren Aufrufe an [[glEvalCoord1]], [[glEvalMesh1]] und [[glEvalPoint1]] Farb-Indizes. Siehe [[glMap1]].

=== GL_MAP1_NORMAL ===
Wenn aktiviert, generieren Aufrufe an [[glEvalCoord1]], [[glEvalMesh1]] und [[glEvalPoint1]] Normalen. Siehe [[glMap1]].

=== GL_MAP1_TEXTURE_COORD_1 ===
Wenn aktiviert, generieren Aufrufe an [[glEvalCoord1]], [[glEvalMesh1]] und [[glEvalPoint1]] s-Texturkoordinaten. Siehe [[glMap1]].

=== GL_MAP1_TEXTURE_COORD_2 ===
Wenn aktiviert, generieren Aufrufe an [[glEvalCoord1]], [[glEvalMesh1]] und [[glEvalPoint1]] s- und t-Texturkoordinaten. Siehe [[glMap1]].
=== GL_MAP1_TEXTURE_COORD_3 ===
Wenn aktiviert, generieren Aufrufe an [[glEvalCoord1]], [[glEvalMesh1]] und [[glEvalPoint1]] s-, t- und r-Texturkoordinaten. Siehe [[glMap1]].

=== GL_MAP1_TEXTURE_COORD_4 ===
Wenn aktiviert, generieren Aufrufe an [[glEvalCoord1]], [[glEvalMesh1]] und [[glEvalPoint1]] s-, t-, r- und q-Texturkoordianten. Siehe [[glMap1]].

=== GL_MAP1_VERTEX_3 ===
Wenn aktiviert, generieren Aufrufe an [[glEvalCoord1]], [[glEvalMesh1]] und [[glEvalPoint1]] x-, y- und z-Vertexkoordinaten. Siehe [[glMap1]].

=== GL_MAP1_VERTEX_4 ===
Wenn aktiviert, generieren Aufrufe an [[glEvalCoord1]], [[glEvalMesh1]] und [[glEvalPoint1]] x-, y-, z- und w-Vertexkoordinaten. Siehe [[glMap1]].

=== GL_MAP2_COLOR_4 ===
Wenn aktiviert, generieren Aufrufe an [[glEvalCoord2]], [[glEvalMesh2]] und [[glEvalPoint2]] RGBA-Werte. Siehe [[glMap2]].

=== GL_MAP2_INDEX ===
Wenn aktiviert, generieren Aufrufe an [[glEvalCoord2]], [[glEvalMesh2]] und [[glEvalPoint2]] Farb-Indizes. Siehe [[glMap2]].

=== GL_MAP2_NORMAL ===
Wenn aktiviert, generieren Aufrufe an [[glEvalCoord2]], [[glEvalMesh2]] und [[glEvalPoint2]] Normale. Siehe [[glMap2]].

=== GL_MAP2_TEXTURE_COORD_1 ===
Wenn aktiviert, generieren Aufrufe an [[glEvalCoord2]], [[glEvalMesh2]] und [[glEvalPoint2]] s-Texturkoordinaten. Siehe [[glMap2]].

=== GL_MAP2_TEXTURE_COORD_2 ===
Wenn aktiviert, generieren Aufrufe an [[glEvalCoord2]], [[glEvalMesh2]] und [[glEvalPoint2]] s- und t-Texturkoordinaten. Siehe [[glMap2]].

=== GL_MAP2_TEXTURE_COORD_3 ===
Wenn aktiviert, generieren Aufrufe an [[glEvalCoord2]], [[glEvalMesh2]] und [[glEvalPoint2]] s-, t- und r-Texturkoordinaten. Siehe [[glMap2]].

=== GL_MAP2_TEXTURE_COORD_4 ===
Wenn aktiviert, generieren Aufrufe an [[glEvalCoord2]], [[glEvalMesh2]] und [[glEvalPoint2]] s-, t-, r- und q-Texturkoordinaten. Siehe [[glMap2]].

=== GL_MAP2_VERTEX_3 ===
Wenn aktiviert, generieren Aufrufe an [[glEvalCoord2]], [[glEvalMesh2]] und [[glEvalPoint2]] x, y und z-Vertexkoordinaten. Siehe [[glMap2]].

=== GL_MAP2_VERTEX_4 ===
Wenn aktiviert, generieren Aufrufe an [[glEvalCoord2]], [[glEvalMesh2]] und [[glEvalPoint2]] x, y, z- und w-Vertexkoordinaten. Siehe [[glMap2]].

=== GL_MULTISAMPLE_EXT ===
Wenn aktiviert, bekommt jeder Pixel im Framepuffer GL_SAMPLES_EXT-Samplepunkte zugewiesen. with it.

=== GL_NORMALIZE ===
Wenn aktiviert, werden via [[glNormal]] angegebene Normalen nach ihrer Transformation auf Einheitslänge skaliert. Siehe [[glNormal]].

=== GL_OCCLUSION_TEST_EXT ===
Wenn aktiviert, wird der Ausschluß-Status (Occlusion, Deutsche Übersetzung ist leider nicht gebräuchlich --[[Benutzer:Sascha Willems|Sascha Willems]] 13:05, 9. Jul 2004 (CEST)) je nach Tiefentest aktualisiert (siehe [[glDepthFunc]]). Der Ausschluß-Status kann mit [[glGetBooleanv]] ausgelesen werden.

=== GL_PIXEL_TEX_GEN_EXT ===
Wenn aktiviert, werden die RGBA-Farben des Bildes genutzt um Texturkoordinaten für das Fragment zu generieren. Siehe [[glPixelTexGenEXT]].

=== GL_POINT_SMOOTH ===
Wenn aktiviert, werden Punkte gefiltert gezeichnet. Ansonsten werden ungefilterte Punkte gerendert. Siehe [[glPointSize]].

=== GL_POLYGON_OFFSET_FILL ===
Wenn aktiviert und das Polygon im GL_FILL-Modus gerendert wird, wird ein Versatz zum Tiefenwert der Fragmente des Polygons addiert, bevor der Tiefentest stattfindet. Siehe [[glPolygonOffset]].

=== GL_POLYGON_OFFSET_LINE ===
Wenn aktiviert und das Polygon im GL_LINE-Modus gerendert wird, wird ein Versatz zum Tiefenwert der Fragmente des Polygons addiert, bevor der Tiefentest stattfindet. Siehe [[glPolygonOffset]].

=== GL_POLYGON_OFFSET_POINT ===
Wenn aktiviert, wird ein Versatz zu den Tiefenwerten der Fragmente eines Polygons addiert, bevor der Tiefentest stattfindet, wenn es im GL_POINT-Modus gerendert wird. Siehe [[glPolygonOffset]].

=== GL_POLYGON_SMOOTH ===
Wenn aktiviert, werden Polygone mit korrekter Filterung gezeichnet, indem der Alphawert eines [[Fragment]]es entsprechend der Deckung gesetzt wird. [[Blenden|Blending]] muss ebenfalls aktiviert sein um korrekte Resultate zu erhalten.
{{Hinweis|Funktion ist meist nicht in Hardware verfügbar, es wird häufig auf Softwaremodus umgeschalten und auch dort nicht immer korrekt gezeichnet.}}

=== GL_POLYGON_STIPPLE ===
Wenn aktiviert, wird das aktuelle Polygon-Punktierungs-Muster zum Rendern der Polygone genutzt. Siehe [[glPolygonStipple]].

=== GL_POST_COLOR_MATRIX_COLOR_TABLE_EXT ===
Wenn aktiviert, werden Farbbild-Komponentne in die Farbtabelle gelegt die nach der Farbmatrix kommt. Siehe [[glColorTableEXT]].

=== GL_POST_CONVOLUTION_COLOR_TABLE_EXT ===
Wenn aktiviert, werden Farbbild-Komponenten in eine Farbtabelle gelegt die nach der Windung, aber vor der Farbmatrix kommt. Siehe [[glColorTableEXT]].

=== GL_RESCALE_NORMAL_EXT ===
Wenn aktiviert, werden Normalen mit einem Reskalierungsfaktor multipliziert, nachdem sie in den Augenraum transformiert wurden und befor sie normalisiert werden. Dieser Faktor wird aus der obersten Reihe der inversen umgestellten Modelansichtsmatrix berechnet.

=== GL_SAMPLE_ALPHA_TO_MASK_EXT ===
Wenn aktiviert, wird der Alphawert eines Fragmentes genutzt um einen temporären Maskenwert zu erstellen, welcher mit dem Maskenwert des Fragmentes verUNDet wird.

=== GL_SAMPLE_ALPHA_TO_ONE_EXT ===
Wenn aktiviert, wird der Alphawert der Fragmente durch den maximal verfügbaren Alphawert ersetzt.

=== GL_SAMPLE_MASK_EXT ===
Wenn aktiviert, wird der Wert von GL_SAMPLE_MASK_VALUE_EXT genutzt um temporäre Maskenwerte zu erstellen, die dann mit den Maskenwerten der Fragmente geUNDet werden. (AND-Verknüpft werden)

=== GL_SCISSOR_TEST ===
Wenn aktiviert, werden Fragmente verworfen die ausserhalb des Scissor-Rechtecks liegen. Siehe [[glScissor]].

=== GL_SEPARABLE_2D_EXT ===
Wenn aktiviert und GL_CONVOLUTION_2D_EXT deaktiviert ist, wird zweidimensionale Wicklung mit separierbarem Filter während des Pixeltransfers durchgeführt. Siehe [[glSeparableFilter2DEXT]].

=== GL_STENCIL_TEST ===
Wenn aktiviert, werden Stempeltests durchgeführt und der Stencilpuffer aktualisiert. Siehe [[glStencilFunc]] und [[glStencilOp]]..

=== GL_TEXTURE_1D ===
Wenn aktiviert, wird eindimensionale Texturierung angewandt (es sei denn zweidimensionale Texturierung wurde auch aktiviert). Siehe [[glTexImage1D]].

=== GL_TEXTURE_2D ===
Wenn aktiviert, wird zweidimensionale Texturierung angewandt (es sei denn dreidimensionale Texturierung wurde auch aktiviert). Siehe [[glTexImage2D]].

=== GL_TEXTURE_3D(''_EXT'') ===
Wenn aktiviert, wird dreidimensionale Texturierung angewandt. Siehe [[glTexImage3DEXT]].

=== GL_TEXTURE_COLOR_TABLE_EXT ===
Wenn aktiviert, wird die gefilterte Texturenfarbe an die Farbtabelle für Texturen angepasst, bevor die Umgebung mit der Fragmentfarbe vermischt wird. Siehe [[glColorTableEXT]].

=== GL_TEXTURE_GEN_Q ===
Wenn aktiviert, wird die q-Texturkoordinate anhand der via [[glTexGen]] definierten Funktion zur Texturgenerierung berechnet. Ansonsten wird die aktuell angegebene q-Texturkoordinate genutzt. Siehe [[glTexGen]].

=== GL_TEXTURE_GEN_R ===
Wenn aktiviert, wird die r-Texturkoordinate anhand der via [[glTexGen]] definierten Funktion zur Texturgenerierung berechnet. Ansonsten wird die aktuell angegebene r-Texturkoordinate genutzt. Siehe [[glTexGen]].

=== GL_TEXTURE_GEN_S ===
Wenn aktiviert, wird die s-Texturkoordinate anhand der via [[glTexGen]] definierten Funktion zur Texturgenerierung berechnet. Ansonsten wird die aktuell angegebene s-Texturkoordinate genutzt. Siehe [[glTexGen]].

=== GL_TEXTURE_GEN_T ===
Wenn aktiviert, wird die t-Texturkoordinate anhand der via [[glTexGen]] definierten Funktion zur Texturgenerierung berechnet. Ansonsten wird die aktuell angegebene t-Texturkoordinate genutzt. Siehe [[glTexGen]].

== Erweiterungen ==
Einige Routinen und Konstanten für diese Funktion sind Teil einer Erweiterung, also nicht Teil des GL-Kerns. Die folgenden Erweiterungen müssen in der durch [[glGetString]] mit dem Argument GL_EXTENSIONS gelieferten Zeichenkette enthalten sein, damit diese genutzt werden können.

=== GL_EXT_color_table ===
'''GL_COLOR_TABLE_EXT''', '''GL_POST_CONVOLUTION_COLOR_TABLE_EXT''' und '''GL_POST_COLOR_MATRIX_COLOR_TABLE_EXT''' sind Teil der Erweiterung [[GL_EXT_color_table]].

=== GL_EXT_convolution ===
'''GL_CONVOLUTION_1D_EXT''', '''GL_CONVOLUTION_2D_EXT''' und '''GL_SEPARABLE_2D_EXT''' sind Teil der Erweiterung [[GL_EXT_convolution]].

=== GL_EXT_fog_offset ===
'''GL_FOG_OFFSET_EXT''' ist Teil der Erweiterung [[GL_EXT_fog_offset]].

=== EXT_interlace ===
'''GL_INTERLACE_EXT''' ist Teil der Erweiterung [[GL_EXT_interlace]].

=== EXT_interlace_read ===
'''GL_INTERLACE_READ_I3D''' ist Teil der Erweiterung [[GL_EXT_interlace_read]].

=== GL_EXT_multisample ===
'''GL_MULTISAMPLE_EXT''', '''GL_SAMPLE_ALPHA_TO_MASK_EXT''', '''GL_SAMPLE_ALPHA_TO_ONE_EXT''' und '''GL_SAMPLE_MASK_EXT''' sind Teil der Erweiterung [[GL_EXT_multisample]].

=== GL_EXT_occlusion_test ===
'''GL_OCCLUSION_TEST_EXT''' ist Teil der Erweiterung [[GL_EXT_occlusion_test]].

=== GL_EXT_pixel_texture ===
'''GL_PIXEL_TEX_GEN_EXT''' ist Teil der Erweiterung [[GL_EXT_pixel_texture]].

=== GL_EXT_rescale_normal ===
'''GL_RESCALE_NORMAL_EXT''' ist Teil der Erweiterung [[GL_EXT_rescale_normal]].

=== GL_EXT_texture3D ===
'''GL_TEXTURE_3D_EXT''' ist Teil der Erweiterung [[GL_EXT_texture3D]].

=== GL_EXT_texture_color_table ===
'''GL_TEXTURE_COLOR_TABLE_EXT''' ist Teil der Erweiterung [[GL_EXT_texture_color_table]].

== Fehlermeldungen ==
GL_INVALID_ENUM wird generiert wenn ''cap'' kein gültiges Token ist.

GL_INVALID_OPERATION wird generiert wenn [[glPixelTransfer]] zwischen [[glBegin]] und dem passenden [[glEnd]] aufgerufen wird.

== Zugehörige Wertrückgaben ==
[[glGet]]
[[glIsEnabled]]

(Die zu übergebenden Argumente können in der Beschreibung zu den beiden Funktionen nachgelesen werden.)

== Siehe auch ==
[[glAlphaFunc]], [[glBitmap]], [[glBlendFunc]], [[glClipPlane]], [[glColorMaterial]], [[glColorTableEXT]], [[glCopyColorTableEXT]], [[glCopyPixels]], [[glCopyTexImage1D]], [[glCopyTexImage2D]], [[glCopyTexSubImage1D]], [[glCopyTexSubImage2D]], [[glCopyTexSubImage3DEXT]], [[glCullFace]], [[glDepthFunc]], [[glDepthRange]], [[glDrawPixels]], [[glEnableClientState]], [[glFog]], [[glGet]], [[glGetString]], [[glIsEnabled]], [[glLight]], [[glLightModel]], [[glLineWidth]], [[glLineStipple]], [[glLogicOp]], [[glMap1]], [[glMap2]], [[glMaterial]], [[glNormal]], [[glPointSize]], [[glPolygonMode]], [[glPolygonOffset]], [[glPolygonStipple]], [[glSampleMaskEXT]], [[glScissor]], [[glStencilFunc]], [[glStencilOp]], [[glTexGen]], [[glTexImage1D]], [[glTexImage2D]], [[glTexImage3DEXT]], [[glTexSubImage1D]], [[glTexSubImage2D]], [[glTexSubImage3DEXT]]

[[Kategorie:GL|Enable]]

Datei:GL POINT SMOOTH aktiviert.png

2006-05-21T06:14:10Z

Lyr: 4-Fach Vergrößerung

4-Fach Vergrößerung

Datei:GL POINT SMOOTH deaktiviert.png

2006-05-21T06:13:54Z

Lyr: 4-Fach Vergrößerung

4-Fach Vergrößerung

Antialiasing

2006-05-21T06:11:03Z

Lyr: + OpenGL Smooth, keine Ahnung ob eine andere Bezeichnung existiert.

Unter Antialiasing versteht man verschiedene Techniken um die Effekte von [[Aliasing]] zu reduzieren. 

Es gibt für die verschiedenen Aliasingeffekte auch entsprechend verschiedene Antialiasing Methoden.

== Antialiasing bei Texturen ==
Bei [[Texturen]] werden hauptsächlich
:[[MipMaps]]
:[[anisotrophisch|anisotrophisches Filtern]]
verwendet.

== Antialiasing an Kanten ==
Um die Treppenbildung an den [[Kante]]n von [[Polygon]]en zu verringen benutzt man
:[[Supersampling]]
:[[Multisampling]]
:[[Jittering]]
:[[OpenGL Smooth]]

Frustum Culling

2006-05-21T03:36:45Z

Lyr:

{{Unvollständig}}
=Was ist das?=
'''Frustum Culling''' ist eine Optimierungsmethode, bei der all die Objekte vom Zeichnen ausgeschlossen werden, die außerhalb des Sichtbereichs (des [[Frustum]]s) liegen.

=Wozu brauch ich es?=
'''Frustum Culling''' sorgt dafür, dass akzeptable Frameraten auch bei großen Szenen möglich sind. Denn durch '''Frustum Culling''' werden viele der Teile der Szene nicht gezeichnet, die man ohnehin nicht sehen kann.

=Wie funktioniert es?=

==Anwendungsspezifisches==
Für eine Anwendung kann Frustum Culling sehr ähnlich wie eine Kollisionsabfrage behandelt werden. Meist wird hier keine exakte Kollisionsabfrage durchgeführt (wie es beispielsweise mit dem Seperation Axis - Algorithmus gemacht werden könnte), sondern es wird lediglich eine eher pessimistische Variante verwendet.

[[Bild:FurstumKollision.GIF]]

''Frustum von oben''

''Links: Eine Kugel die bei der pessimistischen Variante als teilweise innerhalb erkannt wird tatsächlich jedoch ausserhalb liegt.''

''Rechts: Vergleich pessimistische und exakte Kollisionsabfrage mit einer Kugel.''

Für die pessimistische Variante benötigen wir lediglich die 6 Ebenengleichungen des [[Frustum]]s. Danach prüfen wir, ob ein Objekt komplett oder teilweise ausserhalb eines der 6 Halbräume ist, also ob sich das Objekt hinter der entsprechenden Ebene befindet. Nun gibt es 3 Möglichkeiten:
# Objekt komplett hinter mindestens einer Ebene => Objekt überhaupt nicht sichtbar.
# Objekt vor allen 6 Ebenen => Objekt komplett sichtbar
# Objekt mindestens durch eine Ebene teilweise "abgeschnitten", also weder davor noch dahinter.
Im 3. Fall hängt es nun davon ab ob wir eine hierarchische Abfrage durchführen wollen. Also beispielsweise:
* Ein [[Octree]] wo jeder Würfel in bis zu 8 kleinere unterteilt werden kann.
* Gruppen von Objekten (beispielsweise ein Sonnensystem bildet eine Gruppe), wo die einzelnen Objekte noch getrennt abgefragt werden können.
* Der Extremfall wäre das man jedes Dreieck eines Objektes untersucht (was beispielsweise für Raytracer sinnvoll sein ''könnte'').

Wenn wir nun einen hierarchischen Aufbau besitzen, so bedeutet der 3. Fall, dass wir eine Hierarchiestufe weiter nach unten gehen müssen um die Objekte oder Volumen dieser Stufe zu testen.

Wenn wir keinen hierarchischen Aufbau (oder keine weitere Hierarchiestufe mehr) besitzen, so muss natürlich das gesamte Objekt - bzw. alle Dreiecke die sich innerhalb des geprüften Volumen befinden - gezeichnet werden.

Angemerkt sei noch, dass "vor" und "hinter" der Ebene natürlich vom Normalvektor (der für die Ebenengleichung verwendet wird) abhängig ist. Hier wird davon ausgegangen, dass die Normalvektoren in das innere des [[Frustum]]s zeigen.

Je nach Objekttyp lässt sich verhältnismäßig einfach Prüfen ob das Objekt hinter oder vor einer Ebene ist:
*'''Punkt:''' prüfen ob die Ebenengleichung ein positives oder negatives Ergebnis liefert.
*'''Kugel:''' liefert die Ebenengleichung (mit einem normierten [[Normale|Normalvektor]]) für das Zentrum der Kugel einen absoluten Wert (Vorzeichen weg lassen) der kleiner als der Radius der Kugel ist, so schneidet die Kugel die Ebene. Ansonnsten wird gleich wie bei einem Punkt verfahren.
*'''Quader:''' liefern manche Eckpunte ein positives Ergebnis und andere ein Negatives wenn man sie in die Ebenengleichung einsetzt, so schneidet der Quader die Ebene. Liefern alle Punkte ein positives, oder alle Punkte ein negatives Ergebnis, so liegt der Quader gänzlich vor bzw. hinter der Ebene.
*'''Dreieck:''' gleich wie bei einem Quader werden einfach alle Eckpunkte betrachtet, hier natürlich nur 3 statt 8 Eckpunkte.

==Hardwareunterstützung==
===Standard===
[[OpenGL]] teilt automatisch alle Dreiecke welche nicht oder nur teilweise sichtbar sind in einen sichtbaren und eine nicht sichtbaren Bereich ein. Es wird dann nur noch der sichtbare Bereich gezeichnet, oder ggf. natürlich auch gar nichts gezeichnet wenn das Dreieck komplett ausserhalb des [[Frustum]]s liegt. Siehe auch: [[Clipping Plane]].

===[[GL ARB occlusion query|Occlusion Query]] Extension===
Die Extension [[GL ARB occlusion query]] bietet die Möglichkeit abzufragen wieviele [[Pixel]] gezeichnet wurden. Diese Extension wird häufig für Sichtbarkeitsabfragen verwendet, indem man bevor man ein komplexeres Objekt zeichnet nur dessen Bounding Volumen (meist einen Quader) zeichnet und prüft ob davon ein [[Pixel]] auf den Bildschirm landen würde. Ein netter Nebeneffekt an diesen Sichtbarkeitsabfragen ist natürlich, dass auch alle Dreiecke die ausserhalb des [[Frustum]]s liegen keine [[Pixel]] auf den Bildschirm bringen, somit kann man beide Test vereinen. Es kann aber natürlich dennoch hilfreich sein wenn man selbst diese einfacheren Tests etwas gruppiert, um so größere Bereiche die weg fallen gleich von der CPU erkennen zu lassen. Vor allem sehr große Bereiche werden von diesem Test auch nicht erkannt. Man stelle sich hierfür einen Quader vor, der den gesamte [[Frustum]] beinhaltet. Dieser würde ebenfalls kein einziges [[Pixel]] auf dem Bildschirm "wert" sein.

=Siehe auch=
[[Frustum]], [[Clipping Plane]]

=Ressourcen=
[http://delphigl.de/tutorials/frustumcull_de.html Sehr nützliches Tutorial zum Thema Frustum Culling]

Datei:FurstumKollision.GIF

2006-05-21T03:35:55Z

Lyr: Kollisionsabfrage einer Kugel mit der Viewfrustum und Problemfall dabei. Und Vergleich zwischen exakter und pessimistischer Kollisionsabfrage.

Kollisionsabfrage einer Kugel mit der Viewfrustum und Problemfall dabei. Und Vergleich zwischen exakter und pessimistischer Kollisionsabfrage.

Dijkstra

2006-04-09T04:46:46Z

Lyr: /* Erstellung des Graphen */ Fehler im Algorithmus

Dijkstra ist eine spezielle Form des Pathfinding. Hier geht es darum, für beliebig viele Agenten (oder "interessierte" computergesteuerte Einheiten) den kürzesten Weg zu einem bestimmten Ziel zu finden. Dieser Algorithmus ähnelt sehr dem Sprichwort: "Alle Wege führen nach Rom".

=Vorgehensweise=
Ausgehend von Rom (oder einem beliebigen anderen Zielort) erhält ein Graph in alle Richtungen die Kostenangaben (bzw. die Anzahl der Knoten die durchlaufen wurden). Dieser rekursive Vorgang wird so lange durchgeführt bis alle Knoten die Kosten zum Ziel besitzen. Wenn man nun von einem konkreten Knoten zu dem vorgegebenen Ziel möchte, so muss man sich nur den Nachbarknoten mit dem geringsten Wert raus suchen.

=Algorithmus=
==Erstellung des Graphen==
Für diesen Algorithmus müssen die "Kosten_zum_Ziel"-Werte für alle Knoten mit dem maximalen Wert initialisiert werden (zB FFFF Hex für 16 Bit Integer ohne Vorzeichen).
Dijkstra( Knoten Aktuell, Integer Bisherige_Kosten )
Wenn Bisherige_Kosten + Kosten( Aktuell, K ) < K.Kosten_zum_Ziel
K.Kosten_zum_Ziel = Bisherige_Kosten + Kosten( Aktuell, K )

Wenn Knoten Aktuell bisher noch nicht besucht wurde
Für K=alle Nachbarknoten von Aktuell
Dijkstra( K, Bisherige_Kosten + Kosten( Aktuell, K ) )
Die Abfrage "Knoten Aktuell bisher noch nicht besucht" kann entweder über einen eigenen boolean-Wert überprüft werden, oder aber durch einen speziellen Wert für die "Kosten_zum_Ziel" welcher maximial initialisiert wurde, also beispielsweise bei einem 16 Bit Integer ohne Vorzeichen mit FFFF Hex.

Die Erstellung des Graphen benötigt eine Laufzeit von [[O-Notation|O]](n^2) wobei n die Anzahl der Knoten ist. Der Speicherbedarf für diesen Algorithmus (sowohl zur Generierung als auch die fertig generierte Tabelle) ist [[O-Notation|O]](n).

==Suchen eines Weges==
Zum suchen eines Weges von einem gegebenen Startpunkt zum Ziel muss man wie bereits erwähnt für jeden Knoten den Nachbarknoten suchen, welcher am nähesten beim Ziel liegt. Dies geschieht folgendermaßen:
Suche_Weg( Knoten Aktuell )
Wenn Aktuell.Kosten_zum_Ziel = 0
Ziel gefunden

Für K = Knoten mit den geringsten Kosten_zum_Ziel
Suche_Weg( K )
Dieser Algorithmus besitzt eine maximale Laufzeit von [[O-Notation|O]](t*v) wobei t die Tiefe (oder Entfernung) in Knoten des Zieles vom Startpunkt ist, und v der durchschnittliche Verzweigungsgrad des Graphen. Der Speicherbedarf für diesen Algorithmus ist im Idealfall [[O-Notation|O]](1) bzw. O(t) um den gesamten Pfad vom Start bis zum Ziel zu speichern, jedoch benötigt man natürlich die Tabelle von vorher welche einen Speicherbedarf von [[O-Notation|O]](n) besitzt.

Kategorie Diskussion:Exzellent

2006-04-07T15:14:46Z

Lyr: /* Kandidatenliste */ glBegin Kommentar & Stimme

glBegin

2006-04-07T15:00:35Z

Lyr: /* Beschreibung */ GL_POLYGON ist nicht so böse, nur sehr vage spezifiziert ...

= glBegin, glEnd =

== Name ==
'''glBegin, glEnd''' - Umschliessen die [[Eckpunkt|Eckpunkte (Vertices)]] einer [[Primitive|Primitiven]], oder eine Gruppe gleicher [[Primitiv]]en.

== Delphi-Spezifikation ==
procedure '''glBegin'''(''mode'' : GLEnum);
procedure '''glEnd''';

== Parameter ==
<table border=1 rules=all>
<tr>
<td valign="top" width="80px">
''mode''
</td>
<td>
Bestimmt die [[Primitive]] bzw. Gruppe von [[Primitive|Primitiven]] die aus den von '''glBegin''' und '''glEnd''' umschlossenen [[Eckpunkt|Eckpunkten (Vertices)]] erstellt werden.
Erlaubt sind hier die folgenden zehn symbolischen Konstanten :
'''GL_POINTS''', '''GL_LINES''', '''GL_LINE_STRIP''', '''GL_LINE_LOOP''', '''GL_TRIANGLES''', '''GL_TRIANGLE_STRIP''', '''GL_TRIANGLE_FAN''', '''GL_QUADS''', '''GL_QUAD_STRIP''', und '''GL_POLYGON'''.
</td>
</table>

== Beschreibung ==
'''glBegin''' und '''glEnd''' umschliessen eine Liste von [[Eckpunkt|Eckpunkten (Vertices)]] die eine [[Primitive]] oder Gruppe von [[Primitive|Primitiven]] darstellt. '''glBegin''' erhält ein einzelnes Argument (''mode'') das angibt auf welche Art und Weise die [[Eckpunkt|Eckpunkte (Vertices)]] interpretiert werden.

Unter der Annahme ''n'' sei ein Integerwert der bei Eins beginnt und ''N'' als Integerwert der die Gesamtanzahl der übergebenen Eckpunkte angibt, ergeben sich folgende Interpretationen :

{|{{Prettytable_B1}}
!mode
!Beschreibung
!Einschätzung
!Bild
|-
|'''GL_POINTS'''
|Behandelt jeden Eckpunkt als einzelnen Punkt. Eckpunkt ''n'' definiert Punkt ''n'', und ''N'' Punkte werden gerendert.
|align="center"|langsam
|[[Bild:Glbegin_points.jpg|350px|thumb|right]]
|-
|'''GL_LINES'''
|Behandelt jedes Eckpunkt-Paar als unabhängigen Linienabschnitt. Eckpunkte 2*''n''-1 und 2*''n'' beschreiben Linie n. N/2 Linien werden gerendert.
|align="center"|mittel
|[[Bild:Glbegin_lines.jpg|350px|thumb|right]]
|-
|'''GL_LINE_STRIP'''
|Rendert eine Gruppe von miteinander verbundenen Liniensegmenten, beginnend beim ersten Eckpunkt bis zum letzten. Eckpunkte ''n'' und ''n+1'' beschreiben dabei Linie ''n''. ''N-1'' Linien werden gerendert.
|align="center"|schnell
|[[Bild:Glbegin_linestrip.jpg|350px|thumb|right]]
|-
|'''GL_LINE_LOOP'''
|Rendert eine miteinander verbundene Gruppe von Linienabschnitten, beginnend beim ersten Eckpunkt und endend beim letzten, und dann wieder abschliessend zurück zum ersten. Eckpunkte ''n'' und ''n+1'' definieren Linie ''n''. Die letzte Linie wird jedoch durch die Eckpunkte ''N'' und 1 definiert. ''N'' Linien werden gerendert.
|align="center"|sehr schnell
|[[Bild:Glbegin_lineloop.jpg|350px|thumb|right]]
|-
|'''GL_TRIANGLES'''
|Behandelt jedes Eckpunkt-Trio als unabhängiges Dreieck. Eckpunkte 3*''n''-2, 3*''n''-1 und 3*''n'' beschreiben Dreieck ''n''. ''N''/3 Dreiecke werden gerendert.

'''Eigenschaften''':
* Alle Dreiecke bestehen aus jeweils 3 Vertices, die ausschließlich nur zu diesem Dreieck gehören.
|align="center"|schnell
|[[Bild:Glbegin_triangles.jpg|350px|thumb|right]]
|-
|'''GL_TRIANGLE_STRIP'''
|Rendert eine verbundene Gruppe von Dreiecken. Ein Dreieck wird für jeden Eckpunkt der nach den beiden ersten Eckpunkten definiert wird gerendert. Für ein ungerades ''n'' definieren die Eckpunkte ''n'', ''n''+1 und ''n''+2 Dreieck ''n'', für gerade ''n''s definieren die Eckpunkte ''n''+1, ''n'' und ''n''+2 ein Dreieck. ''N''-2 Dreiecke werden gerendert.

'''Eigenschaften''':
* Nacheinander erstellte Dreiecke haben eine gemeinsame Kante.
* Nacheinander erstellte Dreiecke benutzen 2 gemeinsame Vertices.
|align="center"|am schnellsten
|[[Bild:Glbegin_trianglestrip.jpg|350px|thumb|right]]
|-
|'''GL_TRIANGLE_FAN'''
|Rendert eine verbundene Gruppe von Dreiecken. Ein Dreieck wird für jeden Eckpunkt gerendert der nach den ersten beiden definiert wird. Eckpunkte 1, ''n''+1 und ''n''+2 definieren Dreieck ''n''. ''N''-2 Dreiecke werden gerendert.

'''Eigenschaften''':
* Alle Dreiecke haben mindestens einen gemeinsamen Punkt (Vertex1).
* Nacheinander erstellte Dreiecke haben eine gemeinsame Kante.
* Nacheinander erstellte Dreiecke benutzen 2 gemeinsame Vertices.
|align="center"|schnell
|[[Bild:Glbegin_trianglefan.jpg|350px|thumb|right]]
|-
|'''GL_QUADS'''
|Behandelt jeweils vier Eckpunkte als unabhängiges Viereck. Eckpunkte 4*''n''-3, 4*''n''-2, 4*''n''-1 und 4*''n'' beschreiben Viereck ''n''. ''N''/4 Vierecke werden gerendert.

'''Eigenschaften''':
* Alle Vierecke bestehen aus jeweils 4 Vertices, die ausschließlich nur zu diesem Viereck gehören.
|align="center"|schnell
|[[Bild:Glbegin_quads.jpg|350px|thumb|right]]
|-
|'''GL_QUAD_STRIP'''
|Rendert eine verbundene Gruppe von Vierecken. Ein Viereck wird wird für jedes nach den ersten beiden Eckpunkten übergebene Eckpunktepaar gerendert. Eckpunkte 2*''n''-1, 2*''n'', 2*''n''+2 und 2*''n''+1 beschreiben Viereck ''n''. ''N''/2-1 Vierecke werden gerendert. Es gilt allerdings zu beachten, das die Reihenfolge der Eckpunkte die genutzt werden um Vierecke aus einem Streifen zu generieren unterschiedlich ggü. der unabhängigen Konstruktion sind.

'''Eigenschaften''':
* Nacheinander erstellte Vierecke haben eine gemeinsame Kante.
* Nacheinander erstellte Vierecke benutzen 2 gemeinsame Vertices.
|align="center"|sehr schnell
|[[Bild:Glbegin_quadstrip.jpg|350px|thumb|right]]
|-
|'''GL_POLYGON'''
|Rendert eine einzelnes, [[konvex|konvexes]] Polygon (=Vieleck). Eckpunkte 1 bis ''N'' definieren dieses Polygon.
{{Hinweis|GL_POLYGON scheint für Anfänger meist die "beste Lösung" zu sein, denn man kann alle möglichen (konvexen) Polygone erzeugen. Dies ist soweit richtig, allerdings ist GL_POLYGON um ein vielfaches langsamer als GL_TRIANGLES! Dies hat die folgenden Gründe: 
1. sind moderne Grafikkarten auf die Darstellung von Dreiecken optimiert und 
2. müssen die Polygone bevor sie von den Grafikkarten verwendet werden können, erst in Dreiecke zerlegt werden (siehe [[Triangulation]]). 
Vorallem der letzte Punkt sorgt für niedrige Frameraten im Vergleich zu dreiecksbasierten Strukturen. 
Die OpenGL-Spezifikiation erlaubt es jedoch GL_POLYGON annähernd gleich zu behandeln wie GL_TRIANGLE_FAN (die Ausnahme bildet der Wireframe-Modus mit [[glPolygonMode]]), was auch von vielen Grafikkarten in dieser Form umgesetzt wird. Ist dies der Fall, so fallen alle Vor- und Nachteile gegenüber GL_TRIANGLE_FAN weg.}}
|align="center"|langsam
|[[Bild:Glbegin_polygon.jpg|350px|thumb|right]]
|-
|}

Nur eine Untergruppe von GL Befehlen kann zwischen '''glBegin''' und '''glEnd''' genutzt werden. Die Befehle sind [[glVertex]], [[glColor]], [[glIndex]], [[glNormal]], [[glTexCoord]], [[glEvalCoord]], [[glEvalPoint]], [[glArrayElement]], [[glMaterial]], und [[glEdgeFlag]]. Ausserdem ist es erlaubt [[glCallList]] oder [[glCallLists]] zu nutzen um [[Displaylisten]] auszuführen, die nur oben erwähnte Kommandos enthalten. Sollte ein nicht erwähnter GL Befehl zwischen '''glBegin''' und '''glEnd''' ausgeführt werden, dann wird das Fehlerflag gesetzt und der Befehl ignoriert.

Unabhängig des für ''mode'' übergebenen Wertes gibt es '''keine''' Begrenzung für die Anzahl der übergebenen Eckpunkte die zwischen '''glBegin''' und '''glEnd''' definiert werden. Linien, Dreiecke, Vierecke und Polygone die nicht genügenden beschrieben wurden werden nicht gerendert.
Ungenügende Beschreibung bedeutet entweder dass zu wenige Eckpunkte angegeben wurden um eine einzelne [[Primitive]] zu beschreiben, oder ein inkorrektes Vielfaches and Eckpunkten übergeben wurde. Nicht komplette Primitiven werden ignoriert; der Rest wird gerendet.

Das Minimum an zu spezifizierenden Eckpunkten für jede Primitive ist wie folgt :
*1 für einen Punkt
*2 für eine Linie
*3 für ein Dreieck
*4 für ein Viereck und
*3 für ein Polygon.
Modi die ein festgelegtes Vielfaches an Eckpunkten brauchen sind '''GL_LINES''' (2), '''GL_TRIANGLES''' (3), '''GL_QUADS''' (4), und '''GL_QUAD_STRIP''' (2).

Wenn Flächen gemeinsame Punkte haben (z.B. bei '''GL_TRIANGLE_FAN''') ist es nicht möglich die Eigenschaften dieser Vertices für jede Fläche individuell zu bestimmen. Wenn dies nötig sein sollte, müssen die entsprechenden Flächen aus individuellen Vertices zusammengestellt werden.

== Fehlermeldungen ==
'''GL_INVALID_ENUM''' wird ausgelöst wenn ''mode'' einen ungültigen Wert besitzt.

'''GL_INVALID_OPERATION''' wird ausgelöst, wenn zwischen '''glBegin''' und dem zugehörigen '''glEnd''' ein weiteres '''glBegin''' aufgerufen wird.

'''GL_INVALID_OPERATION''' wird ausgelöst, wenn '''glEnd''' ohne ein vorhergehendes '''glBegin''' aufgerufen wird.

'''GL_INVALID_OPERATION''' wird aufgerufen, wenn ein anderer Befehl als [[glVertex]], [[glColor]], [[glIndex]], [[glNormal]], [[glTexCoord]], [[glEvalCoord]], [[glEvalPoint]], [[glArrayElement]], [[glMaterial]], [[glEdgeFlag]], [[glCallList]], oder [[glCallLists]] zwischen '''glBegin''' und dem zugehörigen '''glEnd''' aufgerufen wird.

Ein Aufruf von [[glEnableClientState]], [[glDisableClientState]], [[glPushClientAttrib]], [[glPopClientAttrib]], [[glEdgeFlagPointer]], [[glTexCoordPointer]], [[glColorPointer]], [[glIndexPointer]], [[glNormalPointer]], [[glVertexPointer]], [[glInterleavedArrays]], oder [[glPixelStore]] nach einem Aufruf von '''glBegin''' und dem zugehörigen '''glEnd''' ist nicht erlaubt, aber je nach Implementation wird möglicherweise kein Fehler ausgelöst.

==Beispiele==
<pascal>glBegin(GL_TRIANGLES);
glVertex3f(1,0,0);
glVertex3f(0,1,0);
glVertex3f(0,0,1);
glEnd;</pascal>

Zwischen glBegin und glEnd können natürlich auch "nicht OpenGL"-Befehle stehen was man dazu nutzen kann komplexere Gebilde direkt mit einer Schleife zeichnen zu lassen:

<pascal>glBegin(GL_LINE_STRIP);
for i:=0 to 50 do
begin
glVertex3f(0,i,sin(i/50)*20);
end;
glEnd;</pascal>

== Siehe auch ==
[[glArrayElement]], [[glCallList]], [[glCallLists]], [[glColor]], [[glEdgeFlag]], [[glEvalCoord]], [[glEvalPoint]], [[glIndex]], [[glMaterial]], [[glNormal]], [[glTexCoord]], [[glVertex]]

[[Kategorie:GL|Begin]]

glBegin

2006-04-07T13:31:30Z

Lyr: /* Beschreibung */ Kleiner Tippfehler

= glBegin, glEnd =

== Name ==
'''glBegin, glEnd''' - Umschliessen die [[Eckpunkt|Eckpunkte (Vertices)]] einer [[Primitive|Primitiven]], oder eine Gruppe gleicher [[Primitiv]]en.

== Delphi-Spezifikation ==
procedure '''glBegin'''(''mode'' : GLEnum);
procedure '''glEnd''';

== Parameter ==
<table border=1 rules=all>
<tr>
<td valign="top" width="80px">
''mode''
</td>
<td>
Bestimmt die [[Primitive]] bzw. Gruppe von [[Primitive|Primitiven]] die aus den von '''glBegin''' und '''glEnd''' umschlossenen [[Eckpunkt|Eckpunkten (Vertices)]] erstellt werden.
Erlaubt sind hier die folgenden zehn symbolischen Konstanten :
'''GL_POINTS''', '''GL_LINES''', '''GL_LINE_STRIP''', '''GL_LINE_LOOP''', '''GL_TRIANGLES''', '''GL_TRIANGLE_STRIP''', '''GL_TRIANGLE_FAN''', '''GL_QUADS''', '''GL_QUAD_STRIP''', und '''GL_POLYGON'''.
</td>
</table>

== Beschreibung ==
'''glBegin''' und '''glEnd''' umschliessen eine Liste von [[Eckpunkt|Eckpunkten (Vertices)]] die eine [[Primitive]] oder Gruppe von [[Primitive|Primitiven]] darstellt. '''glBegin''' erhält ein einzelnes Argument (''mode'') das angibt auf welche Art und Weise die [[Eckpunkt|Eckpunkte (Vertices)]] interpretiert werden.

Unter der Annahme ''n'' sei ein Integerwert der bei Eins beginnt und ''N'' als Integerwert der die Gesamtanzahl der übergebenen Eckpunkte angibt, ergeben sich folgende Interpretationen :

{|{{Prettytable_B1}}
!mode
!Beschreibung
!Einschätzung
!Bild
|-
|'''GL_POINTS'''
|Behandelt jeden Eckpunkt als einzelnen Punkt. Eckpunkt ''n'' definiert Punkt ''n'', und ''N'' Punkte werden gerendert.
|align="center"|langsam
|[[Bild:Glbegin_points.jpg|350px|thumb|right]]
|-
|'''GL_LINES'''
|Behandelt jedes Eckpunkt-Paar als unabhängigen Linienabschnitt. Eckpunkte 2*''n''-1 und 2*''n'' beschreiben Linie n. N/2 Linien werden gerendert.
|align="center"|mittel
|[[Bild:Glbegin_lines.jpg|350px|thumb|right]]
|-
|'''GL_LINE_STRIP'''
|Rendert eine Gruppe von miteinander verbundenen Liniensegmenten, beginnend beim ersten Eckpunkt bis zum letzten. Eckpunkte ''n'' und ''n+1'' beschreiben dabei Linie ''n''. ''N-1'' Linien werden gerendert.
|align="center"|schnell
|[[Bild:Glbegin_linestrip.jpg|350px|thumb|right]]
|-
|'''GL_LINE_LOOP'''
|Rendert eine miteinander verbundene Gruppe von Linienabschnitten, beginnend beim ersten Eckpunkt und endend beim letzten, und dann wieder abschliessend zurück zum ersten. Eckpunkte ''n'' und ''n+1'' definieren Linie ''n''. Die letzte Linie wird jedoch durch die Eckpunkte ''N'' und 1 definiert. ''N'' Linien werden gerendert.
|align="center"|sehr schnell
|[[Bild:Glbegin_lineloop.jpg|350px|thumb|right]]
|-
|'''GL_TRIANGLES'''
|Behandelt jedes Eckpunkt-Trio als unabhängiges Dreieck. Eckpunkte 3*''n''-2, 3*''n''-1 und 3*''n'' beschreiben Dreieck ''n''. ''N''/3 Dreiecke werden gerendert.

'''Eigenschaften''':
* Alle Dreiecke bestehen aus jeweils 3 Vertices, die ausschließlich nur zu diesem Dreieck gehören.
|align="center"|schnell
|[[Bild:Glbegin_triangles.jpg|350px|thumb|right]]
|-
|'''GL_TRIANGLE_STRIP'''
|Rendert eine verbundene Gruppe von Dreiecken. Ein Dreieck wird für jeden Eckpunkt der nach den beiden ersten Eckpunkten definiert wird gerendert. Für ein ungerades ''n'' definieren die Eckpunkte ''n'', ''n''+1 und ''n''+2 Dreieck ''n'', für gerade ''n''s definieren die Eckpunkte ''n''+1, ''n'' und ''n''+2 ein Dreieck. ''N''-2 Dreiecke werden gerendert.

'''Eigenschaften''':
* Nacheinander erstellte Dreiecke haben eine gemeinsame Kante.
* Nacheinander erstellte Dreiecke benutzen 2 gemeinsame Vertices.
|align="center"|am schnellsten
|[[Bild:Glbegin_trianglestrip.jpg|350px|thumb|right]]
|-
|'''GL_TRIANGLE_FAN'''
|Rendert eine verbundene Gruppe von Dreiecken. Ein Dreieck wird für jeden Eckpunkt gerendert der nach den ersten beiden definiert wird. Eckpunkte 1, ''n''+1 und ''n''+2 definieren Dreieck ''n''. ''N''-2 Dreiecke werden gerendert.

'''Eigenschaften''':
* Alle Dreiecke haben mindestens einen gemeinsamen Punkt (Vertex1).
* Nacheinander erstellte Dreiecke haben eine gemeinsame Kante.
* Nacheinander erstellte Dreiecke benutzen 2 gemeinsame Vertices.
|align="center"|schnell
|[[Bild:Glbegin_trianglefan.jpg|350px|thumb|right]]
|-
|'''GL_QUADS'''
|Behandelt jeweils vier Eckpunkte als unabhängiges Viereck. Eckpunkte 4*''n''-3, 4*''n''-2, 4*''n''-1 und 4*''n'' beschreiben Viereck ''n''. ''N''/4 Vierecke werden gerendert.

'''Eigenschaften''':
* Alle Vierecke bestehen aus jeweils 4 Vertices, die ausschließlich nur zu diesem Viereck gehören.
|align="center"|schnell
|[[Bild:Glbegin_quads.jpg|350px|thumb|right]]
|-
|'''GL_QUAD_STRIP'''
|Rendert eine verbundene Gruppe von Vierecken. Ein Viereck wird wird für jedes nach den ersten beiden Eckpunkten übergebene Eckpunktepaar gerendert. Eckpunkte 2*''n''-1, 2*''n'', 2*''n''+2 und 2*''n''+1 beschreiben Viereck ''n''. ''N''/2-1 Vierecke werden gerendert. Es gilt allerdings zu beachten, das die Reihenfolge der Eckpunkte die genutzt werden um Vierecke aus einem Streifen zu generieren unterschiedlich ggü. der unabhängigen Konstruktion sind.

'''Eigenschaften''':
* Nacheinander erstellte Vierecke haben eine gemeinsame Kante.
* Nacheinander erstellte Vierecke benutzen 2 gemeinsame Vertices.
|align="center"|sehr schnell
|[[Bild:Glbegin_quadstrip.jpg|350px|thumb|right]]
|-
|'''GL_POLYGON'''
|Rendert eine einzelnes, [[konvex|konvexes]] Polygon (=Vieleck). Eckpunkte 1 bis ''N'' definieren dieses Polygon.
{{Hinweis|GL_POLYGON scheint für Anfänger meist die "beste Lösung" zu sein, denn man kann alle möglichen (konvexen) Polygone erzeugen. Dies ist soweit richtig, allerdings ist GL_POLYGON um ein vielfaches langsamer als GL_TRIANGLES! Dies hat die folgenden Gründe: 
1. sind moderne Grafikkarten auf die Darstellung von Dreiecken optimiert und 
2. müssen die Polygone bevor sie von den Grafikkarten verwendet werden können, erst in Dreiecke zerlegt werden (siehe [[Triangulation]]). 
Vorallem der letzte Punkt sorgt für niedrige Frameraten im Vergleich zu dreiecksbasierten Strukturen.}}
|align="center"|langsam
|[[Bild:Glbegin_polygon.jpg|350px|thumb|right]]
|-
|}

Nur eine Untergruppe von GL Befehlen kann zwischen '''glBegin''' und '''glEnd''' genutzt werden. Die Befehle sind [[glVertex]], [[glColor]], [[glIndex]], [[glNormal]], [[glTexCoord]], [[glEvalCoord]], [[glEvalPoint]], [[glArrayElement]], [[glMaterial]], und [[glEdgeFlag]]. Ausserdem ist es erlaubt [[glCallList]] oder [[glCallLists]] zu nutzen um [[Displaylisten]] auszuführen, die nur oben erwähnte Kommandos enthalten. Sollte ein nicht erwähnter GL Befehl zwischen '''glBegin''' und '''glEnd''' ausgeführt werden, dann wird das Fehlerflag gesetzt und der Befehl ignoriert.

Unabhängig des für ''mode'' übergebenen Wertes gibt es '''keine''' Begrenzung für die Anzahl der übergebenen Eckpunkte die zwischen '''glBegin''' und '''glEnd''' definiert werden. Linien, Dreiecke, Vierecke und Polygone die nicht genügenden beschrieben wurden werden nicht gerendert.
Ungenügende Beschreibung bedeutet entweder dass zu wenige Eckpunkte angegeben wurden um eine einzelne [[Primitive]] zu beschreiben, oder ein inkorrektes Vielfaches and Eckpunkten übergeben wurde. Nicht komplette Primitiven werden ignoriert; der Rest wird gerendet.

Das Minimum an zu spezifizierenden Eckpunkten für jede Primitive ist wie folgt :
*1 für einen Punkt
*2 für eine Linie
*3 für ein Dreieck
*4 für ein Viereck und
*3 für ein Polygon.
Modi die ein festgelegtes Vielfaches an Eckpunkten brauchen sind '''GL_LINES''' (2), '''GL_TRIANGLES''' (3), '''GL_QUADS''' (4), und '''GL_QUAD_STRIP''' (2).

Wenn Flächen gemeinsame Punkte haben (z.B. bei '''GL_TRIANGLE_FAN''') ist es nicht möglich die Eigenschaften dieser Vertices für jede Fläche individuell zu bestimmen. Wenn dies nötig sein sollte, müssen die entsprechenden Flächen aus individuellen Vertices zusammengestellt werden.

== Fehlermeldungen ==
'''GL_INVALID_ENUM''' wird ausgelöst wenn ''mode'' einen ungültigen Wert besitzt.

'''GL_INVALID_OPERATION''' wird ausgelöst, wenn zwischen '''glBegin''' und dem zugehörigen '''glEnd''' ein weiteres '''glBegin''' aufgerufen wird.

'''GL_INVALID_OPERATION''' wird ausgelöst, wenn '''glEnd''' ohne ein vorhergehendes '''glBegin''' aufgerufen wird.

'''GL_INVALID_OPERATION''' wird aufgerufen, wenn ein anderer Befehl als [[glVertex]], [[glColor]], [[glIndex]], [[glNormal]], [[glTexCoord]], [[glEvalCoord]], [[glEvalPoint]], [[glArrayElement]], [[glMaterial]], [[glEdgeFlag]], [[glCallList]], oder [[glCallLists]] zwischen '''glBegin''' und dem zugehörigen '''glEnd''' aufgerufen wird.

Ein Aufruf von [[glEnableClientState]], [[glDisableClientState]], [[glPushClientAttrib]], [[glPopClientAttrib]], [[glEdgeFlagPointer]], [[glTexCoordPointer]], [[glColorPointer]], [[glIndexPointer]], [[glNormalPointer]], [[glVertexPointer]], [[glInterleavedArrays]], oder [[glPixelStore]] nach einem Aufruf von '''glBegin''' und dem zugehörigen '''glEnd''' ist nicht erlaubt, aber je nach Implementation wird möglicherweise kein Fehler ausgelöst.

==Beispiele==
<pascal>glBegin(GL_TRIANGLES);
glVertex3f(1,0,0);
glVertex3f(0,1,0);
glVertex3f(0,0,1);
glEnd;</pascal>

Zwischen glBegin und glEnd können natürlich auch "nicht OpenGL"-Befehle stehen was man dazu nutzen kann komplexere Gebilde direkt mit einer Schleife zeichnen zu lassen:

<pascal>glBegin(GL_LINE_STRIP);
for i:=0 to 50 do
begin
glVertex3f(0,i,sin(i/50)*20);
end;
glEnd;</pascal>

== Siehe auch ==
[[glArrayElement]], [[glCallList]], [[glCallLists]], [[glColor]], [[glEdgeFlag]], [[glEvalCoord]], [[glEvalPoint]], [[glIndex]], [[glMaterial]], [[glNormal]], [[glTexCoord]], [[glVertex]]

[[Kategorie:GL|Begin]]

glBegin

2006-04-07T13:19:57Z

Lyr: /* Fehlermeldungen */ + glPushClientAttrib; + glPopClientAttrib

= glBegin, glEnd =

== Name ==
'''glBegin, glEnd''' - Umschliessen die [[Eckpunkt|Eckpunkte (Vertices)]] einer [[Primitive|Primitiven]], oder eine Gruppe gleicher [[Primitiv]]en.

== Delphi-Spezifikation ==
procedure '''glBegin'''(''mode'' : GLEnum);
procedure '''glEnd''';

== Parameter ==
<table border=1 rules=all>
<tr>
<td valign="top" width="80px">
''mode''
</td>
<td>
Bestimmt die [[Primitive]] bzw. Gruppe von [[Primitive|Primitiven]] die aus den von '''glBegin''' und '''glEnd''' umschlossenen [[Eckpunkt|Eckpunkten (Vertices)]] erstellt werden.
Erlaubt sind hier die folgenden zehn symbolischen Konstanten :
'''GL_POINTS''', '''GL_LINES''', '''GL_LINE_STRIP''', '''GL_LINE_LOOP''', '''GL_TRIANGLES''', '''GL_TRIANGLE_STRIP''', '''GL_TRIANGLE_FAN''', '''GL_QUADS''', '''GL_QUAD_STRIP''', und '''GL_POLYGON'''.
</td>
</table>

== Beschreibung ==
'''glBegin''' und '''glEnd''' umschliessen eine Liste von [[Eckpunkt|Eckpunkten (Vertices)]] die eine [[Primitive]] oder Gruppe von [[Primitive|Primitiven]] darstellt. '''glBegin''' erhält ein einzelnes Argument (''mode'') das angibt auf welche Art und Weise die [[Eckpunkt|Eckpunkte (Vertices)]] interpretiert werden.

Unter der Annahme ''n'' sei ein Integerwert der bei Eins beginnt und ''N'' als Integerwert der die Gesamtanzahl der übergebenen Eckpunkte angibt, ergeben sich folgende Interpretationen :

{|{{Prettytable_B1}}
!mode
!Beschreibung
!Einschätzung
!Bild
|-
|'''GL_POINTS'''
|Behandelt jeden Eckpunkt als einzelnen Punkt. Eckpunkt ''n'' definiert Punkt ''n'', und ''N'' Punkte werden gerendert.
|align="center"|langsam
|[[Bild:Glbegin_points.jpg|350px|thumb|right]]
|-
|'''GL_LINES'''
|Behandelt jedes Eckpunkt-Paar als unabhängigen Linienabschnitt. Eckpunkte 2*''n''-1 und 2*''n'' beschreiben Linie n. N/2 Linien werden gerendert.
|align="center"|mittel
|[[Bild:Glbegin_lines.jpg|350px|thumb|right]]
|-
|'''GL_LINE_STRIP'''
|Rendert eine Gruppe von miteinander verbundenen Liniensegmenten, beginnend beim ersten Eckpunkt bis zum letzten. Eckpunkte ''n'' und ''n+1'' beschreiben dabei Linie ''n''. ''N-1'' Linien werden gerendert.
|align="center"|schnell
|[[Bild:Glbegin_linestrip.jpg|350px|thumb|right]]
|-
|'''GL_LINE_LOOP'''
|Rendert eine miteinander verbundene Gruppe von Linienabschnitten, beginnend beim ersten Eckpunkt und endend beim letzten, und dann wieder abschliessend zurück zum ersten. Eckpunkte ''n'' und ''n+1'' definieren Linie ''n''. Die letzte Linie wird jedich durch die Eckpunkte ''N'' und 1 definiert. ''N'' Linien werden gerendert.
|align="center"|sehr schnell
|[[Bild:Glbegin_lineloop.jpg|350px|thumb|right]]
|-
|'''GL_TRIANGLES'''
|Behandelt jedes Eckpunkt-Trio als unabhängiges Dreieck. Eckpunkte 3*''n''-2, 3*''n''-1 und 3*''n'' beschreiben Dreieck ''n''. ''N''/3 Dreiecke werden gerendert.

'''Eigenschaften''':
* Alle Dreiecke bestehen aus jeweils 3 Vertices, die ausschließlich nur zu diesem Dreieck gehören.
|align="center"|schnell
|[[Bild:Glbegin_triangles.jpg|350px|thumb|right]]
|-
|'''GL_TRIANGLE_STRIP'''
|Rendert eine verbundene Gruppe von Dreiecken. Ein Dreieck wird für jeden Eckpunkt der nach den beiden ersten Eckpunkten definiert wird gerendert. Für ein ungerades ''n'' definieren die Eckpunkte ''n'', ''n''+1 und ''n''+2 Dreieck ''n'', für gerade ''n''s definieren die Eckpunkte ''n''+1, ''n'' und ''n''+2 ein Dreieck. ''N''-2 Dreiecke werden gerendert.

'''Eigenschaften''':
* Nacheinander erstellte Dreiecke haben eine gemeinsame Kante.
* Nacheinander erstellte Dreiecke benutzen 2 gemeinsame Vertices.
|align="center"|am schnellsten
|[[Bild:Glbegin_trianglestrip.jpg|350px|thumb|right]]
|-
|'''GL_TRIANGLE_FAN'''
|Rendert eine verbundene Gruppe von Dreiecken. Ein Dreieck wird für jeden Eckpunkt gerendert der nach den ersten beiden definiert wird. Eckpunkte 1, ''n''+1 und ''n''+2 definieren Dreieck ''n''. ''N''-2 Dreiecke werden gerendert.

'''Eigenschaften''':
* Alle Dreiecke haben mindestens einen gemeinsamen Punkt (Vertex1).
* Nacheinander erstellte Dreiecke haben eine gemeinsame Kante.
* Nacheinander erstellte Dreiecke benutzen 2 gemeinsame Vertices.
|align="center"|schnell
|[[Bild:Glbegin_trianglefan.jpg|350px|thumb|right]]
|-
|'''GL_QUADS'''
|Behandelt jeweils vier Eckpunkte als unabhängiges Viereck. Eckpunkte 4*''n''-3, 4*''n''-2, 4*''n''-1 und 4*''n'' beschreiben Viereck ''n''. ''N''/4 Vierecke werden gerendert.

'''Eigenschaften''':
* Alle Vierecke bestehen aus jeweils 4 Vertices, die ausschließlich nur zu diesem Viereck gehören.
|align="center"|schnell
|[[Bild:Glbegin_quads.jpg|350px|thumb|right]]
|-
|'''GL_QUAD_STRIP'''
|Rendert eine verbundene Gruppe von Vierecken. Ein Viereck wird wird für jedes nach den ersten beiden Eckpunkten übergebene Eckpunktepaar gerendert. Eckpunkte 2*''n''-1, 2*''n'', 2*''n''+2 und 2*''n''+1 beschreiben Viereck ''n''. ''N''/2-1 Vierecke werden gerendert. Es gilt allerdings zu beachten, das die Reihenfolge der Eckpunkte die genutzt werden um Vierecke aus einem Streifen zu generieren unterschiedlich ggü. der unabhängigen Konstruktion sind.

'''Eigenschaften''':
* Nacheinander erstellte Vierecke haben eine gemeinsame Kante.
* Nacheinander erstellte Vierecke benutzen 2 gemeinsame Vertices.
|align="center"|sehr schnell
|[[Bild:Glbegin_quadstrip.jpg|350px|thumb|right]]
|-
|'''GL_POLYGON'''
|Rendert eine einzelnes, [[konvex|konvexes]] Polygon (=Vieleck). Eckpunkte 1 bis ''N'' definieren dieses Polygon.
{{Hinweis|GL_POLYGON scheint für Anfänger meist die "beste Lösung" zu sein, denn man kann alle möglichen (konvexen) Polygone erzeugen. Dies ist soweit richtig, allerdings ist GL_POLYGON um ein vielfaches langsamer als GL_TRIANGLES! Dies hat die folgenden Gründe: 
1. sind moderne Grafikkarten auf die Darstellung von Dreiecken optimiert und 
2. müssen die Polygone bevor sie von den Grafikkarten verwendet werden können, erst in Dreiecke zerlegt werden (siehe [[Triangulation]]). 
Vorallem der letzte Punkt sorgt für niedrige Frameraten im Vergleich zu dreiecksbasierten Strukturen.}}
|align="center"|langsam
|[[Bild:Glbegin_polygon.jpg|350px|thumb|right]]
|-
|}

Nur eine Untergruppe von GL Befehlen kann zwischen '''glBegin''' und '''glEnd''' genutzt werden. Die Befehle sind [[glVertex]], [[glColor]], [[glIndex]], [[glNormal]], [[glTexCoord]], [[glEvalCoord]], [[glEvalPoint]], [[glArrayElement]], [[glMaterial]], und [[glEdgeFlag]]. Ausserdem ist es erlaubt [[glCallList]] oder [[glCallLists]] zu nutzen um [[Displaylisten]] auszuführen, die nur oben erwähnte Kommandos enthalten. Sollte ein nicht erwähnter GL Befehl zwischen '''glBegin''' und '''glEnd''' ausgeführt werden, dann wird das Fehlerflag gesetzt und der Befehl ignoriert.

Unabhängig des für ''mode'' übergebenen Wertes gibt es '''keine''' Begrenzung für die Anzahl der übergebenen Eckpunkte die zwischen '''glBegin''' und '''glEnd''' definiert werden. Linien, Dreiecke, Vierecke und Polygone die nicht genügenden beschrieben wurden werden nicht gerendert.
Ungenügende Beschreibung bedeutet entweder dass zu wenige Eckpunkte angegeben wurden um eine einzelne [[Primitive]] zu beschreiben, oder ein inkorrektes Vielfaches and Eckpunkten übergeben wurde. Nicht komplette Primitiven werden ignoriert; der Rest wird gerendet.

Das Minimum an zu spezifizierenden Eckpunkten für jede Primitive ist wie folgt :
*1 für einen Punkt
*2 für eine Linie
*3 für ein Dreieck
*4 für ein Viereck und
*3 für ein Polygon.
Modi die ein festgelegtes Vielfaches an Eckpunkten brauchen sind '''GL_LINES''' (2), '''GL_TRIANGLES''' (3), '''GL_QUADS''' (4), und '''GL_QUAD_STRIP''' (2).

Wenn Flächen gemeinsame Punkte haben (z.B. bei '''GL_TRIANGLE_FAN''') ist es nicht möglich die Eigenschaften dieser Vertices für jede Fläche individuell zu bestimmen. Wenn dies nötig sein sollte, müssen die entsprechenden Flächen aus individuellen Vertices zusammengestellt werden.

== Fehlermeldungen ==
'''GL_INVALID_ENUM''' wird ausgelöst wenn ''mode'' einen ungültigen Wert besitzt.

'''GL_INVALID_OPERATION''' wird ausgelöst, wenn zwischen '''glBegin''' und dem zugehörigen '''glEnd''' ein weiteres '''glBegin''' aufgerufen wird.

'''GL_INVALID_OPERATION''' wird ausgelöst, wenn '''glEnd''' ohne ein vorhergehendes '''glBegin''' aufgerufen wird.

'''GL_INVALID_OPERATION''' wird aufgerufen, wenn ein anderer Befehl als [[glVertex]], [[glColor]], [[glIndex]], [[glNormal]], [[glTexCoord]], [[glEvalCoord]], [[glEvalPoint]], [[glArrayElement]], [[glMaterial]], [[glEdgeFlag]], [[glCallList]], oder [[glCallLists]] zwischen '''glBegin''' und dem zugehörigen '''glEnd''' aufgerufen wird.

Ein Aufruf von [[glEnableClientState]], [[glDisableClientState]], [[glPushClientAttrib]], [[glPopClientAttrib]], [[glEdgeFlagPointer]], [[glTexCoordPointer]], [[glColorPointer]], [[glIndexPointer]], [[glNormalPointer]], [[glVertexPointer]], [[glInterleavedArrays]], oder [[glPixelStore]] nach einem Aufruf von '''glBegin''' und dem zugehörigen '''glEnd''' ist nicht erlaubt, aber je nach Implementation wird möglicherweise kein Fehler ausgelöst.

==Beispiele==
<pascal>glBegin(GL_TRIANGLES);
glVertex3f(1,0,0);
glVertex3f(0,1,0);
glVertex3f(0,0,1);
glEnd;</pascal>

Zwischen glBegin und glEnd können natürlich auch "nicht OpenGL"-Befehle stehen was man dazu nutzen kann komplexere Gebilde direkt mit einer Schleife zeichnen zu lassen:

<pascal>glBegin(GL_LINE_STRIP);
for i:=0 to 50 do
begin
glVertex3f(0,i,sin(i/50)*20);
end;
glEnd;</pascal>

== Siehe auch ==
[[glArrayElement]], [[glCallList]], [[glCallLists]], [[glColor]], [[glEdgeFlag]], [[glEvalCoord]], [[glEvalPoint]], [[glIndex]], [[glMaterial]], [[glNormal]], [[glTexCoord]], [[glVertex]]

[[Kategorie:GL|Begin]]

Diskussion:OpenGL-Funktionsübersicht

2006-04-05T00:07:07Z

Lyr: /* Versionskritik */

== DGLOpenGL.pas ==
In der DGLOpenGL.pas sind mehr als 1200 "GL" Funktionen eingetragen!!!
Das heißt jetzt aber nicht das wir im Wiki noch 1000 Funktionen beschreiben müssen da viele Funktionen in der DGLOpenGL.pas sich nur durch die Parameter unterscheiden. Allerdings dürfte das verdammt viel Arbeit sein die OpenGL Funktioen "von Hand" zu vergleichen ob sie im Wiki sind oder nicht. Darum würde ich vorschlagen dies von einem Programm machen zu lassen.

MfG
Flo
----
Also ich kenn mich mit PHP net gut genug aus, um hier nen Parser zu schreiben. Sicherlich einfacher wärs direkt die Datenbank abzugrasen. Aber ich glaube bei meinem Wiki gesehn zu haben, dass in den DB-Spalten die gesamten Zeilen als Wikicode gespeichert sind. Parsen muss man also wahrscheinlich immer. Die Idee vom Programm ansich ist aber durchaus gut. Das Programm müsste dann also Bot-Like die Funktionsübersicht updaten.
--[[Benutzer:Flash (Kevin Fleischer)|Flash (Kevin Fleischer)]] 18:50, 24. Apr 2005 (CEST)
----

== Welche Funktionen wollen wir im Wiki auflisten? ==

In der DGLOpenGL.pas stehen OpenGL Funktionen mit den verschiedensten Endungen wie: ARB, EXT, ATI, NV, SGIS, APPLE, SUN und MESA. Welche davon sollen wir bei GL auflisten?

----
Alle. Die ARB und EXT können direkt bei den GL Funktionen (wenns denn glXxxxARB sind) eingetragen werden. Die Herstellerspezifischen haben ne Extrakategorie am Ende der Seite. Sollten aber erstmal weniger Priorität haben. Wichtig ist erstmal der GL-Kern + die fast zum Kern gehören.
--[[Benutzer:Flash (Kevin Fleischer)|Flash (Kevin Fleischer)]] 18:50, 24. Apr 2005 (CEST)
----

== Versionskritik ==
glDeleteTextures ... wirklich erst ab 1.1? GenTextures (das Gegenstück) war ja wie ich meinen möchte bereits in 1.0 drinnen, somit würde ich mich ziemlich wundern wenn DeleteTextures erst in 1.1 gekommen ist.

Multitexturing ... ich glaube dies schon mal angesprochen zu haben, also wenn 1.3 ok ist dann füge ich mich :-), aber eigentlich war das eine 1.2.1 (sogar die einzige) wenn ich mich nicht irre.

Vertex Arrays ... ist ne 1.1 Geschichte wenn ich mich nicht irre, habe ich auch korrigiert, aber ich bin mir nur zu 99,9% sicher also Kritik willkommen. Darunter fallen: ArrayElement, ColorPointer, DisableClientState, DrawArrays, DrawElements, EdgeFlagPointer, EnableClientState, IndexPointer, NormalPointer, TexCoordPointer und VertexPointer.

--[[Benutzer:Lyr|Lyr]] 03:41, 3. Apr 2006 (CEST)

----
glDeleteTextures ist bei 1.0 dabei. Ich würde aber aktuell sowieso auf die [[testseite2]] verweisen, die diese hier langfristig ersetzen soll.

Die Vertex Arrays sind nicht erst bei 1.1 hinzugekommen, soweit ich verstanden habe nur die aktuellen Funktionen:

'Arrays of vertex data may be transferred to the GL with many fewer commands than were previously necessary.'

Daher existierten Vertex Arrays auch in 1.0. Wobei ich mir in den Punkt unsicher bin.

Zum Multitexturing:
In 1.2.1 ist Multitexturing als ARB-Erweiterung von SGIS_multitexture hinzugekommen.
Erst bei 1.3 wurde es eine Kernfunktion.

--[[Benutzer:I0n0s|I0n0s]] 11:34, 3. Apr 2006 (CEST)

----
"In 1.2.1 ist Multitexturing als ARB-Erweiterung von SGIS_multitexture hinzugekommen."

Mein Fehler, wurde auch damals schon erwähnt, ich war nur zu blöd mich daran zu erinnern.

"'Arrays of vertex data may be transferred to the GL with many fewer commands than were previously necessary.'
Daher existierten Vertex Arrays auch in 1.0."

Wenn man den gesamten Text liest auf den du dich beziehst (übrigens hier zu finden: [http://www.opengl.org/documentation/specs/version1.1/glspec1.1/index.html OGL-1.1 Spezifikation], Unterpunkt [http://www.opengl.org/documentation/specs/version1.1/glspec1.1/node133.html#SECTION001200000000000000000 C: Version 1.1], der Teil über [http://www.opengl.org/documentation/specs/version1.1/glspec1.1/node134.html#SECTION001210000000000000000 Vertex Arrays] damit andere auch mit reden können), so macht dies auf mich doch eher den Eindruck, dass diese Funktionen erst in 1.1 verfügbar waren. Vor allem der Satz: "The primary goal was to decrease the number of subroutine calls required to transfer non-display listed geometry data to the GL." lässt mich vermuten dass diese Funktionen vorher überhaupt nicht definiert waren, denn wenn sie definiert gewesen wären, dann bräuchte man keine Extension dafür, sondern hätte einfach den/die Grafikkartentreiber entsprechend geändert. Aber es ist natürlich etwas blöd dass man kaum noch (bis gar keine) OGL 1.0 Spezifikationen in die Hand bekommt. Vielleicht ne blöde Idee, aber man könnte ja die Jungs von SGI fragen ob sie sowas noch haben :-).

--[[Benutzer:Lyr|Lyr]] 02:07, 5. Apr 2006 (CEST)

Diskussion:OpenGL-Funktionsübersicht

2006-04-03T01:45:47Z

Lyr: /* Versionskritik */ DrawElements vergessen ...

OpenGL-Funktionsübersicht

2006-04-03T01:45:13Z

Lyr: /* D */ DrawElements vergessen ....

== Was hier hinein gehört ==

Um eine Funktionsübersicht aller OpenGL Funktionen zu erreichen die inhaltlich korrekt ist, sollten die [http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL.tar.gz orginal Spezifikationen] von OpenGL.org übersetzt werden([[Link#OpenGL_Funktionen|Alternative Quellen]]).

Allerdings sind hier auch glu-/wgl- und glx-Funktionen erlaubt. Konstanten bitte nicht hier im Inhaltsverzeichnis einfügen, genausowenig wie [[OpenGL-Extensions]].

Die Funktionen sind bereits nach Gruppen sortiert (GL/GLU/etc.). Sollten Funktionen noch nicht in der Übersicht auftauchen, welche aber definitiv existieren, können diese nachgetragen werden. Funktionen die es in verschiedenen Ausprägungen gibt, werden ohne Parameterangabe eingetragen (also glVertex statt glVertex3f).

Bitte haltet euch bei der Formatierung der Befehlsbeschreibung an die [[Funktionsvorlage]] (ich führe hier mal glBegin als Beispiel an), und erklärt nicht mehr als nötig.
Wenn ihr also einen Befehl habt der etwas mit VertexArrays zu tun hat, dann gehört dort '''nicht''' hinein was ein VertexArray ist oder bringt. Das gehört dann nach [[Techniken und Algorithmen]] oder [[Hintergrundwissen]] (je nach Thematik) und sollte dann in der Funktionsbeschreibung als ''interner Link'' untergebracht werden.

'''Zu aller erst sollte die Orginalspezifikation übersetzt werden''' und erst dann eigene Hinweise untergebracht werden (z.B. Erfahrungen, typische Fehler etc.)

==Artikel-Vorlage==
'''Wichtiger Hinweis ''' : Bei der Funktionsübersicht ist v.a. eine einheitliche Gliederung der Artikel wichtig. Deshalb haltet euch bitte an '''[[Funktionsvorlage|folgende Vorlage]]'''!

==Kategorisieren von Artikeln==
Das Wiki ermöglicht es einen Artikel einer Kategorie zuzuordnen. Diese Möglichkeit sollte von Artikelschreibern genutzt werden.
Man ordnet einen Artikel einer Kategorie zu, in dem man '''am Ende des Artikels einen Link zu der Kategrie erstellt''' der er zugeordnet werden soll:

{| border="1" cellspacing="0"
|+Beispiel
|
{| border="0" cellspacing="4"
|<nowiki>[[Kategorie:GL|Name ohne "gl"]]</nowiki>
|}
|}

Das sind die neuen Kategorien:
*[[:Kategorie:GL]]
*[[:Kategorie:GLU]]
*[[:Kategorie:GLX]]
*[[:Kategorie:WGL]]

== [[:Kategorie:GL|GL]] ==
Abkürzung für '''G'''raphics '''L'''ibrary, hierunter fallen alle Funktionen die direkter Bestandteil (entweder als Kernfunktion oder über Extensions) der OpenGL sind.

=== A ===
[[glAccum]] 
[[glActiveTexture]] {{Version_1_3}} 
[[glAddSwapHintRectWIN]] 
[[glAlphaFunc]] 
[[glAreTexturesResident]] 
[[glArrayElement]] {{Version_1_1}} 
[[glAttachObject]] {{Version_2_0}} 
[[glAttachShader]] {{Version_2_0}} 

=== B ===
[[glBegin]] 
[[glBeginQuery]] {{Version_1_5}} 
[[glBindAttribLocationARB]] 
[[glBindBuffer]] {{Version_1_5}} 
[[glBindProgrammARB]] 
[[glBindTexture]] 
[[glBitmap]] 
[[glBlendColor]] {{Version_1_2}} 
[[glBlendEquation]] {{Version_1_2}} 
[[glBlendFunc]] 
[[glBlendFuncSeparate]] {{Version_1_4}} 
[[glBufferData]] {{Version_1_5}} 
[[glBufferSubData]] {{Version_1_5}}

=== C ===
[[glCallList]] 
[[glCallLists]] 
[[glClear]] 
[[glClearAccum]] 
[[glClearColor]] 
[[glClearDepth]] 
[[glClearIndex]] 
[[glClearStencil]] 
[[glClientActiveTexture]] {{Version_1_3}} 
[[glClipPlane]] 
[[glColor]] 
[[glColorMask]] 
[[glColorMaterial]] 
[[glColorPointer]] {{Version_1_1}} 
[[glColorSubTable]] {{Version_1_2}} 
[[glColorTable]] {{Version_1_2}} 
[[glColorTableParameter]] {{Version_1_2}} 
[[glCompileShader]] {{Version_2_0}} 
[[glCompressedTexSubImage]] {{Version_1_3}} 
[[glCompressedTexImage]] {{Version_1_3}} 
[[glConvolutionFilter1D]] {{Version_1_2}} 
[[glConvolutionFilter2D]] {{Version_1_2}} 
[[glConvolutionParameter]] {{Version_1_2}} 
[[glCopyColorSubTable]] {{Version_1_2}} 
[[glCopyColorTable]] {{Version_1_2}} 
[[glCopyConvolutionFilter]] {{Version_1_2}} 
[[glCopyPixels]] 
[[glCopyTexImage1D]] 
[[glCopyTexImage2D]] 
[[glCopyTexSubImage]] 
[[glCreateProgramObject]] {{Version_2_0}} [[glCreateProgramObjectARB]] 
[[glCreateShaderObject]] {{Version_2_0}} [[glCreateShaderObjectARB]] 
[[glCullFace]] 
[[glCurrentPaletteMatrixARB]] 

=== D ===
[[glDeleteLists]] 
[[glDeleteObject]] {{Version_2_0}} 
[[glDeleteShader]] {{Version_2_0}} 
[[glDetachObject]] {{Version_2_0}} 
[[glDetachShader]] {{Version_2_0}} 
[[glDeleteBuffers]] {{Version_1_5}} 
[[glDeleteProgram]] {{Version_2_0}} [[glDeleteProgramsARB]] 
[[glDeleteQueries]] {{Version_1_5}} 
[[glDeleteTextures]] {{Version_1_1}} 
[[glDepthFunc]] 
[[glDepthMask]] 
[[glDepthRange]] 
[[glDisable]] 
[[glDisableClientState]] {{Version_1_1}} 
[[glDisableVertexAttribArrayARB]] 
[[glDrawArrays]] {{Version_1_1}} 
[[glDrawBuffer]] 
[[glDrawElements]] {{Version_1_1}} 
[[glDrawPixels]] 
[[glDrawRangeElements]] {{Version_1_2}}

=== E ===
[[glEdgeFlag]] 
[[glEdgeFlagPointer]] {{Version_1_1}} 
[[glEnable]] 
[[glEnableClientState]] {{Version_1_1}} 
[[glEnableVertexAttribArrayARB]] 
[[glEnd]] 
[[glEndList]] 
[[glEndQuery]] {{Version_1_5}} 
[[glEvalCoord]] 
[[glEvalMesh]] 
[[glEvalPoint]] 

=== F ===
[[glFeedbackBuffer]] 
[[glFinish]] 
[[glFlush]] 
[[glFog]] 
[[glFogCoord]] {{Version_1_4}} 
[[glFogCoordPointer]] {{Version_1_4}} 
[[glFrontFace]] 
[[glFrustum]] 

=== G ===
[[glGenBuffers]] {{Version_1_5}} 
[[glGenLists]] 
[[glGenTextures]] 
[[glGenProgramsARB]] 
[[glGenQueries]] {{Version_1_5}} 
[[glGet]] 
[[glGetActiveAttribARB]] 
[[glGetActiveUniform]] {{Version_2_0}} [[glGetActiveUniformARB]] 
[[glGetAttachedObjects]] {{Version_2_0}} [[glGetAttachedObjectsARB]] 
[[glGetAttachedShaders]] {{Version_2_0}} 
[[glGetAttribLocationARB]] 
[[glGetBooleanv]] 
[[glGetBufferParameteriv]] {{Version_1_5}} 
[[glGetBufferPointerv]] {{Version_1_5}} 
[[glGetBufferSubData]] {{Version_1_5}} 
[[glGetClipPlane]] 
[[glGetColorTable]] {{Version_1_2}} 
[[glGetColorTableParameter]] {{Version_1_2}} 
[[glGetCompressedTexImage]] {{Version_1_3}} 
[[glGetConvolutionFilter]] {{Version_1_2}} 
[[glGetConvolutionParameter]] {{Version_1_2}} 
[[glGetDoublev]] 
[[glGetError]] 
[[glGetFloatv]] 
[[glGetHandle]] {{Version_2_0}} [[glGetHandleARB]] 
[[glGetHistogram]] {{Version_1_2}} 
[[glGetHistogramParameter]] {{Version_1_2}} 
[[glGetInfoLog]] {{Version_2_0}} [[glGetInfoLogARB]] 
[[glGetIntegerv]] 
[[glGetLight]] 
[[glGetMap]] 
[[glGetMaterial]] 
[[glGetMinmax]] {{Version_1_2}} 
[[glGetMinmaxParameter]] {{Version_1_2}} 
[[glGetObjectParameter]] {{Version_2_0}} [[glGetObjectParameterARB]] 
[[glGetPixelMap]] 
[[glGetPointerv]] 
[[glGetPolygonStipple]] 
[[glGetProgramARB]] 
[[glGetProgramEnvParameterARB]] 
[[glGetProgramLocalParameterARB]] 
[[glGetProgramStringARB]] 
[[glGetQueryiv]] {{Version_1_5}} 
[[glGetQueryObject]] {{Version_1_5}} 
[[glGetSeparableFilter]] {{Version_1_2}} 
[[glGetShaderSource]] {{Version_2_0}} [[glGetShaderSourceARB]] 
[[glGetString]] 
[[glGetTexEnv]] 
[[glGetTexGen]] 
[[glGetTexImage]] 
[[glGetTexLevelParameter]] 
[[glGetTexParameter]] 
[[glGetUniform]] {{Version_2_0}} [[glGetUniformARB]] 
[[glGetUniformLocation]] {{Version_2_0}} [[glGetUniformLocationARB]] 
[[glGetVertexAttribARB]] 
[[glGetVertexAttribPointervARB]] 

=== H ===
[[glHint]] 
[[glHistogram]] {{Version_1_2}} 

=== I ===
[[glIndex]] 
[[glIndexMask]] 
[[glIndexPointer]] {{Version_1_1}} 
[[glInitNames]] 
[[glInterleavedArrays]] 
[[glIsBuffer]] {{Version_1_5}} 
[[glIsEnabled]] 
[[glIsList]] 
[[glIsProgram]] {{Version_2_0}} 
[[glIsQuery]] {{Version_1_5}} 
[[glIsShader]] {{Version_2_0}} 
[[glIsTexture]] 

=== L ===
[[glLight]] 
[[glLightModel]] 
[[glLineStipple]] 
[[glLineWidth]] 
[[glLinkProgram]] {{Version_2_0}} 
[[glListBase]] 
[[glLoadIdentity]] 
[[glLoadMatrix]] 
[[glLoadName]] 
[[glLoadTransposeMatrix]] {{Version_1_3}} 
[[glLogicOp]] 

=== M ===
[[glMap1]] 
[[glMap2]] 
[[glMapBuffer]] {{Version_1_5}} 
[[glMapGrid]] 
[[glMaterial]] 
[[glMatrixIndexARB]] 
[[glMatrixIndexPointerARB]] 
[[glMatrixMode]] 
[[glMinMax]]{{Version_1_2}} 
[[glMultiDrawArrays]] {{Version_1_4}} 
[[glMultiDrawElements]] {{Version_1_4}} 
[[glMultiTexCoord]] {{Version_1_3}} 
[[glMultMatrix]] 
[[glMultTransposeMatrix]] {{Version_1_3}}

=== N ===
[[glNewList]] 
[[glNormal]] 
[[glNormalPointer]] {{Version_1_1}} 

=== 0 ===
[[glOrtho]] 

=== P ===
[[glPassThrough]] 
[[glPixelMap]] 
[[glPixelStore]] 
[[glPixelTransfer]] 
[[glPixelZoom]] 
[[glPointParameter]] {{Version_1_4}} 
[[glPointSize]] 
[[glPolygonMode]] 
[[glPolygonOffset]] 
[[glPolygonStipple]] 
[[glPopAttrib]] 
[[glPopClientAttrib]] 
[[glPopMatrix]] 
[[glPopName]] 
[[glPrioritizeTextures]] 
[[glProgramEnvParameterARB]] 
[[glProgramLocalParameterARB]] 
[[glProgramStringARB]] 
[[glPushAttrib]] 
[[glPushClientAttrib]] 
[[glPushMatrix]] 
[[glPushName]] 

=== R ===
[[glRasterPos]] 
[[glReadBuffer]] 
[[glReadPixels]] 
[[glRect]] 
[[glRenderMode]] 
[[glResetHistogram]] {{Version_1_2}} 
[[glResetMinmax]] {{Version_1_2}} 
[[glRotate]] 

=== S ===
[[glSampleCoverage]] {{Version_1_3}} 
[[glScale]] 
[[glScissor]] 
[[glSecondaryColor]] {{Version_1_4}} 
[[glSecondaryColorPointer]] {{Version_1_4}} 
[[glSelectBuffer]] 
[[glSeparableFilter2D]] {{Version_1_2}} 
[[glShadeModel]] 
[[glShaderSource]] {{Version_2_0}} [[glShaderSourceARB]] 
[[glStencilFunc]] 
[[glStencilMask]] 
[[glStencilOp]] 

=== T ===
[[glTexCoord]] 
[[glTexCoordPointer]] {{Version_1_1}} 
[[glTexEnv]] 
[[glTexGen]] 
[[glTexImage|glTexImage1D]] 
[[glTexImage|glTexImage2D]] 
[[glTexImage|glTexImage3D]] 
[[glTexParameter]] 
[[glTexSubImage1D]] 
[[glTexSubImage2D]] 
[[glTexSubImage3D]] 
[[glTranslate]] 

=== U ===
[[glUniform]] {{Version_2_0}} [[glUniformARB]] 
[[glUniformMatrix]] {{Version_2_0}} [[glUniformMatrixARB]] 
[[glUseProgramObject]] {{Version_2_0}} [[glUseProgramObjectARB]] 
[[glUnmapBuffer]] {{Version_1_5}}

=== V ===
[[glValidateProgram]] {{Version_2_0}} [[glValidateProgramARB]] 
[[glVertex]] 
[[glVertexAttribARB]] 
[[glVertexAttribPointerARB]] 
[[glVertexBlendARB]] 
[[glVertexPointer]] {{Version_1_1}} 
[[glViewport]]

=== W ===
[[glWeightARB]] 
[[glWeightPointerARB]] 
[[glWindowPos]] {{Version_1_4}}

== [[:Kategorie:GLU|GLU]] ==
(Was ist die [[GLU]]?) 

=== B ===
[[gluBeginCurve]] 
[[gluBeginPolygon]] 
[[gluBeginSurface]] 
[[gluBeginTrim]] 
[[gluBuild1DMipmaps]] 
[[gluBuild2DMipmaps]] 

=== C ===
[[gluCylinder]] 

=== D ===
[[gluDeleteNurbsRenderer]] 
[[gluDeleteQuadric]] 
[[gluDeleteTess]] 
[[gluDisk]] 

=== E ===
[[gluEndCurve]] 
[[gluEndPolygon]] 
[[gluEndSurface]] 
[[gluEndTrim]] 
[[gluErrorString]] 

=== G ===
[[gluGetNurbsProperty]] 
[[gluGetString]] 
[[gluGetTessProperty]] 

=== L ===
[[gluLoadSamplingMatrices]] 
[[gluLookAt]] 

=== N ===
[[gluNewNurbsRenderer]] 
[[gluNewQuadric]] 
[[gluNewTess]] 
[[gluNextContour]] 
[[gluNurbsCallback]] 
[[gluNurbsCurve]] 
[[gluNurbsProperty]] 
[[gluNurbsSurface]] 

=== O ===
[[gluOrtho2D]] 

=== P ===
[[gluPartialDisk]] 
[[gluPerspective]] 
[[gluPickMatrix]] 
[[gluProject]] 
[[gluPwlCurve]] 

=== Q ===
[[gluQuadricCallback]] 
[[gluQuadricDrawStyle]] 
[[gluQuadricNormals]] 
[[gluQuadricOrientation]] 
[[gluQuadricTexture]] 

=== S ===
[[gluScaleImage]] 
[[gluSphere]] 

=== T ===
[[gluTessBeginContour]] 
[[gluTessBeginPolygon]] 
[[gluTessCallback]] 
[[gluTessEndContour]] 
[[gluTessEndPolygon]] 
[[gluTessNormal]] 
[[gluTessProperty]] {{icpIcon}} 
[[gluTessVertex]] 

=== U ===
[[gluUnProject]] 

== [[:Kategorie:GLX|GLX]] ==
(Was ist die [[GLX]] {{icpIcon}}?) 
=== C ===
[[glXChooseVisual]] 
[[glXCopyContext]] 
[[glXCreateContext]] 
[[glXCreateGLXPixmap]] 

=== D ===
[[glXDestroyContext]] 
[[glXDestroyGLXPixmap]] 

=== F ===
[[glXFreeContextEXT]] 
=== G ===
[[glXGetClientString]] 
[[glXGetConfig]] 
[[glXGetCurrentContextIDEXT]] 
[[glxGetCurrentContext]] 
[[glxGetCurrentDisplay]] 
[[glxGetCurrentDrawable]] 
=== I ===
[[glXImportContextEXT]] 
[[glXIntro]] 
[[glxIsDirect]] 

=== M ===
[[glXMakeCurrent]] 
=== Q ===
[[glXQueryContextInfoEXT]] 
[[glxQueryExtension]] 
[[glXQueryExtensionsString]] 
[[glXQueryServerString]] 
[[glXQureyVersion]] 
=== S ===
[[glxSwapBuffers]] 
=== U ===
[[glXUseXFont]] 
=== W ===
[[glXWaitGL]] 
[[glXWaitX]] 

== [[:Kategorie:WGL|WGL]] ==
(Was ist die [[WGL]]?) 

=== C ===
[[wglChoosePixelFormatARB]] 
[[wglCopyContext]] 
[[wglCreateContext]] 
[[wglCreateBufferRegionEXT]] 
[[wglCreateLayerContext]] 
[[wglCreatePbufferARB]] 

=== D ===
[[wglDeleteBufferRegionEXT]] 
[[wglDeleteContext]] 
[[wglDestroyPbufferARB]] 
[[wglDescribeLayerPlane]] 

=== G ===
[[wglGetCurrentContext]] 
[[wglGetCurrentDC]] 
[[wglGetCurrentReadDC]] 
[[wglGetExtensionsStringARB]] 
[[wglGetLayerPaletteEntries]] 
[[wglGetPbufferDCARB]] 
[[wglGetPixelFormatAttribARB]] 
[[wglGetPixelFormatAttribEXT]] 
[[wglGetProcAddress]] 

=== M ===
[[wglMakeCurrent]] 
[[wglMakeCurrentContextEXT]] 

=== Q ===
[[wglQueryPbufferARB]] 

=== R ===
[[wglRealizeLayerPalette]] 
[[wglReleasePbufferDCARB]] 
[[wglRestoreBufferRegionEXT]] 

=== S ===
[[wglSaveBufferRegionEXT]] 
[[wglSetLayerPaletteEntries]] 
[[wglShareLists]] 
[[wglSwapIntervalEXT]] 
[[wglSwapLayerBuffers]] 

=== U ===
[[wglUseFontBitmaps]] 
[[wglUseFontOutlines]] 

== Externe Funktionen ==
Hier sind alle Funktionen zu finden, die zwar direkt nichts mit OpenGL zu tun haben, aber trotzdem im Normalfall zur Nutzung der GL benötigt werden.

=== Win32 Funktionen ===
[[ChoosePixelFormat]] 
[[DescribePixelFormat]] 
[[GetPixelFormat]] 
[[SetPixelFormat]] 
[[SwapBuffers]] 

=== Linux / Unix Funktionen ===
[[XCloseDisplay]] 
[[XDefaultScreen]] 
[[XOpenDisplay]] 

===Siehe auch===
[[SDL-Funktionsübersicht]]

== OpenGL Parameter-Tabellen ==
Hier gehören alle Parameter-Tabellen hin. Dies sind Listen von Parametern, die bei vielen OpenGL-Funktionen immer wieder auftauchen.

[[internes Pixelformat|interne Pixelformate]] 
[[Pixelformat|Pixelformate]] 
[[Pixeldatentyp|Datentypen für Pixel]]

Diskussion:OpenGL-Funktionsübersicht

2006-04-03T01:41:50Z

Lyr:

OpenGL-Funktionsübersicht

2006-04-03T01:38:56Z

Lyr: Vertex Arrays erst ab 1.1

== Was hier hinein gehört ==

Um eine Funktionsübersicht aller OpenGL Funktionen zu erreichen die inhaltlich korrekt ist, sollten die [http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL.tar.gz orginal Spezifikationen] von OpenGL.org übersetzt werden([[Link#OpenGL_Funktionen|Alternative Quellen]]).

Allerdings sind hier auch glu-/wgl- und glx-Funktionen erlaubt. Konstanten bitte nicht hier im Inhaltsverzeichnis einfügen, genausowenig wie [[OpenGL-Extensions]].

Die Funktionen sind bereits nach Gruppen sortiert (GL/GLU/etc.). Sollten Funktionen noch nicht in der Übersicht auftauchen, welche aber definitiv existieren, können diese nachgetragen werden. Funktionen die es in verschiedenen Ausprägungen gibt, werden ohne Parameterangabe eingetragen (also glVertex statt glVertex3f).

Bitte haltet euch bei der Formatierung der Befehlsbeschreibung an die [[Funktionsvorlage]] (ich führe hier mal glBegin als Beispiel an), und erklärt nicht mehr als nötig.
Wenn ihr also einen Befehl habt der etwas mit VertexArrays zu tun hat, dann gehört dort '''nicht''' hinein was ein VertexArray ist oder bringt. Das gehört dann nach [[Techniken und Algorithmen]] oder [[Hintergrundwissen]] (je nach Thematik) und sollte dann in der Funktionsbeschreibung als ''interner Link'' untergebracht werden.

'''Zu aller erst sollte die Orginalspezifikation übersetzt werden''' und erst dann eigene Hinweise untergebracht werden (z.B. Erfahrungen, typische Fehler etc.)

==Artikel-Vorlage==
'''Wichtiger Hinweis ''' : Bei der Funktionsübersicht ist v.a. eine einheitliche Gliederung der Artikel wichtig. Deshalb haltet euch bitte an '''[[Funktionsvorlage|folgende Vorlage]]'''!

==Kategorisieren von Artikeln==
Das Wiki ermöglicht es einen Artikel einer Kategorie zuzuordnen. Diese Möglichkeit sollte von Artikelschreibern genutzt werden.
Man ordnet einen Artikel einer Kategorie zu, in dem man '''am Ende des Artikels einen Link zu der Kategrie erstellt''' der er zugeordnet werden soll:

{| border="1" cellspacing="0"
|+Beispiel
|
{| border="0" cellspacing="4"
|<nowiki>[[Kategorie:GL|Name ohne "gl"]]</nowiki>
|}
|}

Das sind die neuen Kategorien:
*[[:Kategorie:GL]]
*[[:Kategorie:GLU]]
*[[:Kategorie:GLX]]
*[[:Kategorie:WGL]]

== [[:Kategorie:GL|GL]] ==
Abkürzung für '''G'''raphics '''L'''ibrary, hierunter fallen alle Funktionen die direkter Bestandteil (entweder als Kernfunktion oder über Extensions) der OpenGL sind.

=== A ===
[[glAccum]] 
[[glActiveTexture]] {{Version_1_3}} 
[[glAddSwapHintRectWIN]] 
[[glAlphaFunc]] 
[[glAreTexturesResident]] 
[[glArrayElement]] {{Version_1_1}} 
[[glAttachObject]] {{Version_2_0}} 
[[glAttachShader]] {{Version_2_0}} 

=== B ===
[[glBegin]] 
[[glBeginQuery]] {{Version_1_5}} 
[[glBindAttribLocationARB]] 
[[glBindBuffer]] {{Version_1_5}} 
[[glBindProgrammARB]] 
[[glBindTexture]] 
[[glBitmap]] 
[[glBlendColor]] {{Version_1_2}} 
[[glBlendEquation]] {{Version_1_2}} 
[[glBlendFunc]] 
[[glBlendFuncSeparate]] {{Version_1_4}} 
[[glBufferData]] {{Version_1_5}} 
[[glBufferSubData]] {{Version_1_5}}

=== C ===
[[glCallList]] 
[[glCallLists]] 
[[glClear]] 
[[glClearAccum]] 
[[glClearColor]] 
[[glClearDepth]] 
[[glClearIndex]] 
[[glClearStencil]] 
[[glClientActiveTexture]] {{Version_1_3}} 
[[glClipPlane]] 
[[glColor]] 
[[glColorMask]] 
[[glColorMaterial]] 
[[glColorPointer]] {{Version_1_1}} 
[[glColorSubTable]] {{Version_1_2}} 
[[glColorTable]] {{Version_1_2}} 
[[glColorTableParameter]] {{Version_1_2}} 
[[glCompileShader]] {{Version_2_0}} 
[[glCompressedTexSubImage]] {{Version_1_3}} 
[[glCompressedTexImage]] {{Version_1_3}} 
[[glConvolutionFilter1D]] {{Version_1_2}} 
[[glConvolutionFilter2D]] {{Version_1_2}} 
[[glConvolutionParameter]] {{Version_1_2}} 
[[glCopyColorSubTable]] {{Version_1_2}} 
[[glCopyColorTable]] {{Version_1_2}} 
[[glCopyConvolutionFilter]] {{Version_1_2}} 
[[glCopyPixels]] 
[[glCopyTexImage1D]] 
[[glCopyTexImage2D]] 
[[glCopyTexSubImage]] 
[[glCreateProgramObject]] {{Version_2_0}} [[glCreateProgramObjectARB]] 
[[glCreateShaderObject]] {{Version_2_0}} [[glCreateShaderObjectARB]] 
[[glCullFace]] 
[[glCurrentPaletteMatrixARB]] 

=== D ===
[[glDeleteLists]] 
[[glDeleteObject]] {{Version_2_0}} 
[[glDeleteShader]] {{Version_2_0}} 
[[glDetachObject]] {{Version_2_0}} 
[[glDetachShader]] {{Version_2_0}} 
[[glDeleteBuffers]] {{Version_1_5}} 
[[glDeleteProgram]] {{Version_2_0}} [[glDeleteProgramsARB]] 
[[glDeleteQueries]] {{Version_1_5}} 
[[glDeleteTextures]] {{Version_1_1}} 
[[glDepthFunc]] 
[[glDepthMask]] 
[[glDepthRange]] 
[[glDisable]] 
[[glDisableClientState]] {{Version_1_1}} 
[[glDisableVertexAttribArrayARB]] 
[[glDrawArrays]] {{Version_1_1}} 
[[glDrawBuffer]] 
[[glDrawElements]] 
[[glDrawPixels]] 
[[glDrawRangeElements]] {{Version_1_2}}

=== E ===
[[glEdgeFlag]] 
[[glEdgeFlagPointer]] {{Version_1_1}} 
[[glEnable]] 
[[glEnableClientState]] {{Version_1_1}} 
[[glEnableVertexAttribArrayARB]] 
[[glEnd]] 
[[glEndList]] 
[[glEndQuery]] {{Version_1_5}} 
[[glEvalCoord]] 
[[glEvalMesh]] 
[[glEvalPoint]] 

=== F ===
[[glFeedbackBuffer]] 
[[glFinish]] 
[[glFlush]] 
[[glFog]] 
[[glFogCoord]] {{Version_1_4}} 
[[glFogCoordPointer]] {{Version_1_4}} 
[[glFrontFace]] 
[[glFrustum]] 

=== G ===
[[glGenBuffers]] {{Version_1_5}} 
[[glGenLists]] 
[[glGenTextures]] 
[[glGenProgramsARB]] 
[[glGenQueries]] {{Version_1_5}} 
[[glGet]] 
[[glGetActiveAttribARB]] 
[[glGetActiveUniform]] {{Version_2_0}} [[glGetActiveUniformARB]] 
[[glGetAttachedObjects]] {{Version_2_0}} [[glGetAttachedObjectsARB]] 
[[glGetAttachedShaders]] {{Version_2_0}} 
[[glGetAttribLocationARB]] 
[[glGetBooleanv]] 
[[glGetBufferParameteriv]] {{Version_1_5}} 
[[glGetBufferPointerv]] {{Version_1_5}} 
[[glGetBufferSubData]] {{Version_1_5}} 
[[glGetClipPlane]] 
[[glGetColorTable]] {{Version_1_2}} 
[[glGetColorTableParameter]] {{Version_1_2}} 
[[glGetCompressedTexImage]] {{Version_1_3}} 
[[glGetConvolutionFilter]] {{Version_1_2}} 
[[glGetConvolutionParameter]] {{Version_1_2}} 
[[glGetDoublev]] 
[[glGetError]] 
[[glGetFloatv]] 
[[glGetHandle]] {{Version_2_0}} [[glGetHandleARB]] 
[[glGetHistogram]] {{Version_1_2}} 
[[glGetHistogramParameter]] {{Version_1_2}} 
[[glGetInfoLog]] {{Version_2_0}} [[glGetInfoLogARB]] 
[[glGetIntegerv]] 
[[glGetLight]] 
[[glGetMap]] 
[[glGetMaterial]] 
[[glGetMinmax]] {{Version_1_2}} 
[[glGetMinmaxParameter]] {{Version_1_2}} 
[[glGetObjectParameter]] {{Version_2_0}} [[glGetObjectParameterARB]] 
[[glGetPixelMap]] 
[[glGetPointerv]] 
[[glGetPolygonStipple]] 
[[glGetProgramARB]] 
[[glGetProgramEnvParameterARB]] 
[[glGetProgramLocalParameterARB]] 
[[glGetProgramStringARB]] 
[[glGetQueryiv]] {{Version_1_5}} 
[[glGetQueryObject]] {{Version_1_5}} 
[[glGetSeparableFilter]] {{Version_1_2}} 
[[glGetShaderSource]] {{Version_2_0}} [[glGetShaderSourceARB]] 
[[glGetString]] 
[[glGetTexEnv]] 
[[glGetTexGen]] 
[[glGetTexImage]] 
[[glGetTexLevelParameter]] 
[[glGetTexParameter]] 
[[glGetUniform]] {{Version_2_0}} [[glGetUniformARB]] 
[[glGetUniformLocation]] {{Version_2_0}} [[glGetUniformLocationARB]] 
[[glGetVertexAttribARB]] 
[[glGetVertexAttribPointervARB]] 

=== H ===
[[glHint]] 
[[glHistogram]] {{Version_1_2}} 

=== I ===
[[glIndex]] 
[[glIndexMask]] 
[[glIndexPointer]] {{Version_1_1}} 
[[glInitNames]] 
[[glInterleavedArrays]] 
[[glIsBuffer]] {{Version_1_5}} 
[[glIsEnabled]] 
[[glIsList]] 
[[glIsProgram]] {{Version_2_0}} 
[[glIsQuery]] {{Version_1_5}} 
[[glIsShader]] {{Version_2_0}} 
[[glIsTexture]] 

=== L ===
[[glLight]] 
[[glLightModel]] 
[[glLineStipple]] 
[[glLineWidth]] 
[[glLinkProgram]] {{Version_2_0}} 
[[glListBase]] 
[[glLoadIdentity]] 
[[glLoadMatrix]] 
[[glLoadName]] 
[[glLoadTransposeMatrix]] {{Version_1_3}} 
[[glLogicOp]] 

=== M ===
[[glMap1]] 
[[glMap2]] 
[[glMapBuffer]] {{Version_1_5}} 
[[glMapGrid]] 
[[glMaterial]] 
[[glMatrixIndexARB]] 
[[glMatrixIndexPointerARB]] 
[[glMatrixMode]] 
[[glMinMax]]{{Version_1_2}} 
[[glMultiDrawArrays]] {{Version_1_4}} 
[[glMultiDrawElements]] {{Version_1_4}} 
[[glMultiTexCoord]] {{Version_1_3}} 
[[glMultMatrix]] 
[[glMultTransposeMatrix]] {{Version_1_3}}

=== N ===
[[glNewList]] 
[[glNormal]] 
[[glNormalPointer]] {{Version_1_1}} 

=== 0 ===
[[glOrtho]] 

=== P ===
[[glPassThrough]] 
[[glPixelMap]] 
[[glPixelStore]] 
[[glPixelTransfer]] 
[[glPixelZoom]] 
[[glPointParameter]] {{Version_1_4}} 
[[glPointSize]] 
[[glPolygonMode]] 
[[glPolygonOffset]] 
[[glPolygonStipple]] 
[[glPopAttrib]] 
[[glPopClientAttrib]] 
[[glPopMatrix]] 
[[glPopName]] 
[[glPrioritizeTextures]] 
[[glProgramEnvParameterARB]] 
[[glProgramLocalParameterARB]] 
[[glProgramStringARB]] 
[[glPushAttrib]] 
[[glPushClientAttrib]] 
[[glPushMatrix]] 
[[glPushName]] 

=== R ===
[[glRasterPos]] 
[[glReadBuffer]] 
[[glReadPixels]] 
[[glRect]] 
[[glRenderMode]] 
[[glResetHistogram]] {{Version_1_2}} 
[[glResetMinmax]] {{Version_1_2}} 
[[glRotate]] 

=== S ===
[[glSampleCoverage]] {{Version_1_3}} 
[[glScale]] 
[[glScissor]] 
[[glSecondaryColor]] {{Version_1_4}} 
[[glSecondaryColorPointer]] {{Version_1_4}} 
[[glSelectBuffer]] 
[[glSeparableFilter2D]] {{Version_1_2}} 
[[glShadeModel]] 
[[glShaderSource]] {{Version_2_0}} [[glShaderSourceARB]] 
[[glStencilFunc]] 
[[glStencilMask]] 
[[glStencilOp]] 

=== T ===
[[glTexCoord]] 
[[glTexCoordPointer]] {{Version_1_1}} 
[[glTexEnv]] 
[[glTexGen]] 
[[glTexImage|glTexImage1D]] 
[[glTexImage|glTexImage2D]] 
[[glTexImage|glTexImage3D]] 
[[glTexParameter]] 
[[glTexSubImage1D]] 
[[glTexSubImage2D]] 
[[glTexSubImage3D]] 
[[glTranslate]] 

=== U ===
[[glUniform]] {{Version_2_0}} [[glUniformARB]] 
[[glUniformMatrix]] {{Version_2_0}} [[glUniformMatrixARB]] 
[[glUseProgramObject]] {{Version_2_0}} [[glUseProgramObjectARB]] 
[[glUnmapBuffer]] {{Version_1_5}}

=== V ===
[[glValidateProgram]] {{Version_2_0}} [[glValidateProgramARB]] 
[[glVertex]] 
[[glVertexAttribARB]] 
[[glVertexAttribPointerARB]] 
[[glVertexBlendARB]] 
[[glVertexPointer]] {{Version_1_1}} 
[[glViewport]]

=== W ===
[[glWeightARB]] 
[[glWeightPointerARB]] 
[[glWindowPos]] {{Version_1_4}}

== [[:Kategorie:GLU|GLU]] ==
(Was ist die [[GLU]]?) 

=== B ===
[[gluBeginCurve]] 
[[gluBeginPolygon]] 
[[gluBeginSurface]] 
[[gluBeginTrim]] 
[[gluBuild1DMipmaps]] 
[[gluBuild2DMipmaps]] 

=== C ===
[[gluCylinder]] 

=== D ===
[[gluDeleteNurbsRenderer]] 
[[gluDeleteQuadric]] 
[[gluDeleteTess]] 
[[gluDisk]] 

=== E ===
[[gluEndCurve]] 
[[gluEndPolygon]] 
[[gluEndSurface]] 
[[gluEndTrim]] 
[[gluErrorString]] 

=== G ===
[[gluGetNurbsProperty]] 
[[gluGetString]] 
[[gluGetTessProperty]] 

=== L ===
[[gluLoadSamplingMatrices]] 
[[gluLookAt]] 

=== N ===
[[gluNewNurbsRenderer]] 
[[gluNewQuadric]] 
[[gluNewTess]] 
[[gluNextContour]] 
[[gluNurbsCallback]] 
[[gluNurbsCurve]] 
[[gluNurbsProperty]] 
[[gluNurbsSurface]] 

=== O ===
[[gluOrtho2D]] 

=== P ===
[[gluPartialDisk]] 
[[gluPerspective]] 
[[gluPickMatrix]] 
[[gluProject]] 
[[gluPwlCurve]] 

=== Q ===
[[gluQuadricCallback]] 
[[gluQuadricDrawStyle]] 
[[gluQuadricNormals]] 
[[gluQuadricOrientation]] 
[[gluQuadricTexture]] 

=== S ===
[[gluScaleImage]] 
[[gluSphere]] 

=== T ===
[[gluTessBeginContour]] 
[[gluTessBeginPolygon]] 
[[gluTessCallback]] 
[[gluTessEndContour]] 
[[gluTessEndPolygon]] 
[[gluTessNormal]] 
[[gluTessProperty]] {{icpIcon}} 
[[gluTessVertex]] 

=== U ===
[[gluUnProject]] 

== [[:Kategorie:GLX|GLX]] ==
(Was ist die [[GLX]] {{icpIcon}}?) 
=== C ===
[[glXChooseVisual]] 
[[glXCopyContext]] 
[[glXCreateContext]] 
[[glXCreateGLXPixmap]] 

=== D ===
[[glXDestroyContext]] 
[[glXDestroyGLXPixmap]] 

=== F ===
[[glXFreeContextEXT]] 
=== G ===
[[glXGetClientString]] 
[[glXGetConfig]] 
[[glXGetCurrentContextIDEXT]] 
[[glxGetCurrentContext]] 
[[glxGetCurrentDisplay]] 
[[glxGetCurrentDrawable]] 
=== I ===
[[glXImportContextEXT]] 
[[glXIntro]] 
[[glxIsDirect]] 

=== M ===
[[glXMakeCurrent]] 
=== Q ===
[[glXQueryContextInfoEXT]] 
[[glxQueryExtension]] 
[[glXQueryExtensionsString]] 
[[glXQueryServerString]] 
[[glXQureyVersion]] 
=== S ===
[[glxSwapBuffers]] 
=== U ===
[[glXUseXFont]] 
=== W ===
[[glXWaitGL]] 
[[glXWaitX]] 

== [[:Kategorie:WGL|WGL]] ==
(Was ist die [[WGL]]?) 

=== C ===
[[wglChoosePixelFormatARB]] 
[[wglCopyContext]] 
[[wglCreateContext]] 
[[wglCreateBufferRegionEXT]] 
[[wglCreateLayerContext]] 
[[wglCreatePbufferARB]] 

=== D ===
[[wglDeleteBufferRegionEXT]] 
[[wglDeleteContext]] 
[[wglDestroyPbufferARB]] 
[[wglDescribeLayerPlane]] 

=== G ===
[[wglGetCurrentContext]] 
[[wglGetCurrentDC]] 
[[wglGetCurrentReadDC]] 
[[wglGetExtensionsStringARB]] 
[[wglGetLayerPaletteEntries]] 
[[wglGetPbufferDCARB]] 
[[wglGetPixelFormatAttribARB]] 
[[wglGetPixelFormatAttribEXT]] 
[[wglGetProcAddress]] 

=== M ===
[[wglMakeCurrent]] 
[[wglMakeCurrentContextEXT]] 

=== Q ===
[[wglQueryPbufferARB]] 

=== R ===
[[wglRealizeLayerPalette]] 
[[wglReleasePbufferDCARB]] 
[[wglRestoreBufferRegionEXT]] 

=== S ===
[[wglSaveBufferRegionEXT]] 
[[wglSetLayerPaletteEntries]] 
[[wglShareLists]] 
[[wglSwapIntervalEXT]] 
[[wglSwapLayerBuffers]] 

=== U ===
[[wglUseFontBitmaps]] 
[[wglUseFontOutlines]] 

== Externe Funktionen ==
Hier sind alle Funktionen zu finden, die zwar direkt nichts mit OpenGL zu tun haben, aber trotzdem im Normalfall zur Nutzung der GL benötigt werden.

=== Win32 Funktionen ===
[[ChoosePixelFormat]] 
[[DescribePixelFormat]] 
[[GetPixelFormat]] 
[[SetPixelFormat]] 
[[SwapBuffers]] 

=== Linux / Unix Funktionen ===
[[XCloseDisplay]] 
[[XDefaultScreen]] 
[[XOpenDisplay]] 

===Siehe auch===
[[SDL-Funktionsübersicht]]

== OpenGL Parameter-Tabellen ==
Hier gehören alle Parameter-Tabellen hin. Dies sind Listen von Parametern, die bei vielen OpenGL-Funktionen immer wieder auftauchen.

[[internes Pixelformat|interne Pixelformate]] 
[[Pixelformat|Pixelformate]] 
[[Pixeldatentyp|Datentypen für Pixel]]

Perlin Noise

2006-04-02T23:56:53Z

Lyr:

Perlin Noise ist ein Fraktal-Algorithmus welcher mit sehr einfachen Formeln komplexe und theoretisch endlose Gebilde berechnen kann. Da Perlin Noise darauf basiert, scheinbar zufällige Funktionen mit weichen Übergängen (die Steigung kann einen gewissen Wert nicht überschreiten) zu benutzen, eignet er sich sehr gut zur Simulation verschiedenster, natürlicher Phänomene wie Beispielsweise:
* Wolken
* Landschaftshöhen- und auch Texturen
* eventuell auch Texturen wie Wasser, Feuer und ähnliches

=Grundlagen=
Perlin Noise basiert auf der Überlagerung von Frequenzen. Bei einer niedrigen Frequenz wird zwischen 2 eher weit voneinander entfernten angegebenen Werten interpoliert. Bei der höchsten (sinnvollen) Frequenz wird für jeden dargestellten Wert (zB jedes Pixel) ein anderer Wert berechnet. Die Werte werden aus Pseudozufallszahlen für eine Positionsangabe gebildet. Die Positionsangabe kann hier eine beliebige Dimension besitzen (beispielsweise 2D für eine Heightmap, 3D für eine Volumentrische Textur, ...). Die Ausgabe ist üblicherweise 1 Wert welcher beliebig interpretiert werden kann.

== Zufallswerte aber wie? ==

Es wird eine Funktion benötigt die für jede Dimension einen Parameter hat und für die gleichen Parameter auch die gleichen Zahlen liefert.
<pascal>// 1. Dimension
function Werte1D(X:Integer):ErgebnisTyp
// 2.Dimension
function Werte2D(X,Y:Integer):ErgebnisTyp</pascal>

=== mit einen Array===

Diese Aufgabe kann ein Array erfüllen welcheswelches man zuvor mit Zufallswerten gefüllt hat.
also:
<pascal>
Werte1D:array [0..X_Werte_Max] of ErgebnisTyp;
Werte2D:array [0..X_Werte_Max,0..Y_Werte_Max] of ErgebnisTyp;</pascal>

=== eigene Zufallsfunktion ===
Ein gängiger Algorithmus sieht beispielsweise so aus:
x := x + Seed;
x := ( x shl 13 ) xor x;
rand := 1 - ( (x * (x * x * 15731 + 789221) + 1376312589) and $7fffffff) / 1073741824;
Rand liefert hier einen Wert für eine 1 Dimensionale Positionsangabe (X - Ganzzahl) einen Wert zwischen -1 und 1. Für 2 Dimensionen könnte dieser Code folgendermaßen erweitert werden:
n := x + y * 57 + Seed;
n := ( n shl 13 ) xor n;
rand := 1 - ( (n * (n * n * 15731 + 789221) + 1376312589) and $7fffffff) / 1073741824;
im weiteren wird diese Funktionalität mit Random( Pos ) bzw. Random( PosX, PosY ) verwendet.

==[[Interpolation]]==

Zwischen den Werten aus dem Array versucht man nun mit einer [[Interpolation]] schöne Übergänge zu schaffen. Am schnellsten ist die lineare [[Interpolation]], jedoch kann durch einen Trick auch eine Sinus artige [[Interpolation]] sehr schnell ablaufen. Auf den folgenden Bildern sieht man links linear [[Interpolation|interpolierte]] Höhenwerte und auf der rechten seite eine Sinus/Cosinus artige [[Interpolation]]. Die größern Punkte entsprechen den im Array abgespeicherten Zufallswerten.

[[Bild:Interpolation.png|center]]

Die [[Interpolation]]s funktion muss zunächst einmal die beiden zu interpolierenden Werte entgegen nehmen. Zusätzlich muss noch durch mindestens einen weiteren Parameter klar werden, welche Position (im obrigen Bild X) den gesuchte Wert haben soll.

Wäre einem die Ausführgeschwindigkeit egal, könnten die beiden Interpolations Funktionen folgerndermaßen aussehen:

<pascal>//Hineis: nicht getestet

function InterpoliereLinear(Wert1,Wert2,FaktorWert1:Real);
// Lineare Interpolation von zwei Werten
// FaktorWert1 muss zwischen 0 und 1 liegen
begin
result := Wert1*FaktorWert1 + Wert2*(1-FaktorWert1);
end;

function InterpoliereCos(Wert1,Wert2,FaktorWert1:Real);
// Cosinus/Sinus artige Interpolation von zwei werten;
// FaktorWert muss zwischen 0 und 1 liegen
begin
result := Wert1*((cos(pi/2*FaktorWert1)+1)/2) + Wert2*(1-(cos(pi/2*FaktorWert1)+1)/2)
end;</pascal>

Jedoch möchte man meistens möglichst schnelle Berechnungen haben. Besonders die Sinus und Cosinus Funktionen können unter Umständen zum Problem werden. Um trotzdem Sinuns- und Cosinus-Interpolation zu erzeugen kann man im Vorraus sich ein Array mit Interpolationswerten anlegen. Da Rechner schneller mit Integerwerten als mit Gleitkommerwerten rechnen werden wir im folgenden Beispiel erstere verwenden.

<pascal>

var
Interpolation:array [0..Interpolation_Bereich-1]of Integer;
//Interpoaltions_Bereich ist legt die Maximale Anzahl an Punkten fest,
// die für zwei Interpolationswerte ermittelt werden können(inklusive Randpunkte).

const
Interpolation_Max = 1000 // * entspricht dem Wert 1.000;
// * je höher dieser Wert deso genauer das Ergebnis.
// * je höher dieser Wert ist deso niedriger müssen
// die Interpolationswerte sein

procedure BeimStart;
begin
{..}
// Im Interpolations Array werden mit den Werten die von Interpolation_Max bis 0 gehen gefüllt.
// wobei Interpolation[0] = Interpolation_Max ist
// und Interploation[high(Interpolation)] = 0 ist
for i := 0 to high(Interpolation) do Interpolation[I] := round((cos(pi/(Interpolation_Bereich-1)*i)+1)/2*Interpolation_Max);
{..}
end;

function Interpoliere(Wert1,Wert2:Integer;Nr,Von:Integer):Integer;
// Interpoliert zwischen 2 Werten
// Nr ist gibt den Punkt an den man ermitteln möchte. Von die Anzahl der Interpolations schrite
var
Wert1_Faktor:Integer;
begin
if Nr > Von then raise ERangeError.CreateFmt('Nr Wert %d nicht in 0..%d',[Nr,Von-1]);
if Von > Interpolations_Bereich raise ERangeError.CreateFmt('Von Wert %d nicht in 0..%d',[0,-1]);
Wert1_Faktor := Interpolation[(Interpolation_Bereich* Nr)div Von];
result := (Wert1*Wert1_Faktor) div Interpolation_Max
+ (Wert2*(1000 - Wert1_Faktor)) div Interpolation_Max;
end;</pascal>

Dies wäre die [[Interpolation]] für eine 1 Dimensionale Positionsangabe. Natürlich müssen aber auch die anderen Dimensionen [[Interpolation|interpoliert]] werden. Dies kann aber (wenn gewünscht) ebenfalls mit mehreren [[Interpolation]]en von 2 Werten erfolgen
PosX = Ganzzahl( Position.x )
PosY = Ganzzahl( Position.y )
X1 = Interpoliere( Random( PosX, PosY ), Random( PosX, PosY + 1 ), Nachkommateil( Position.y ) )
X2 = Interpoliere( Random( PosX + 1, PosY), Random( PosX + 1, PosY + 1, Nachkommateil( Position.y ) )
Ergebnis = Interpoliere( X1, X2, Nachkommateil( Position.x ) )

=Algorithmus=
Mit den oben beschriebenen Funktionen ist der Algorithmus recht schnell zu machen.

==Die Parameter==
Der Perlin Noise Algorithmus erhält üblicherweise folgende Parameter:
*Double: Position (Die Position wird bereits entsprechend skaliert)
*Double: Persistenz (wie stark ist der Einfluss der höheren Frequenzen)
*Wertebereich: Double: Min, Double: Max
*Integer: Rechentiefe (Detailgrad)
*Gegebenenfalls Double: Frequenzfaktor (oder Standard auf 2)
Die Laufzeit für einen berechneten Wert beträgt [[O-Notation|O]]( n ) wobei n die Rechentiefe angibt.

==Überlagerung der Frequenzen==
Es wird für jeden Detailgrad ein Wert berechnet. Da Perlin Noise für einen einzelnen Wert kaum Sinn macht und im Normalfall für mehrere nebeneinander liegende Positionen ein Wert berechnet wird, kann man auch von Frequenzbändern sprechen. Der Code könnte beispielsweise so aussehen:
Wert = 0
Für jeden Detailgrad
Wert = Wert + InterpolierterWert( Position * Frequenz )
Frequenz = Frequenz * Frequenzfaktor
Wie hier unschwer zu erkennen ist werden die Werte addiert (also überlagert).

[[Bild:PerlinUeberlagerung.png|center|framed|''Abb.1: Frequenzbänder für 200 Werte (Pixel).'' 
''Frequenzfaktor = 2; Persitenz = 0.5;'' 
''Links oben: Frequenz 0.01 (Einheit = Pixel)'' 
''Rechts oben: Frequenz 0.02'' 
''Links unten: Frequenz 0.04'' 
''Rechts unten: überlagerte (addierte) Frequenzbänder (für die ersten 3 Detailgrade)'']]

==Rechentiefe==
Die Rechentiefe gibt an wie hoch der Detailgrad sein soll. In Abbildung 1 (siehe Frequenzen) wurde beispielsweise eine Rechentiefe von 3 verwendet. Bei einem 2 Dimensionalen Perlin Noise dürfte dies jedoch deutlichere Unterschiede zeigen (siehe Abbildung 2).

[[Bild:PerlinTiefe.png|center|framed|''Abb. 2: Unterschiedliche Rechentiefen.'' 
''Frequenzfaktor = 2; Persitenz = 0.5;'' 
''Links oben: Rechentiefe 1'' 
''Rechts oben: Rechentiefe 2'' 
''Links unten: Rechentiefe 3'' 
''Rechts unten: Rechentiefe 4'']]

==Persistenz==
Die Persistenz gibt an wie stark die höheren Frequenzbänder Einfluss auf das Ergebnis haben sollen. Hierfür erweitern wir den unter '''Überlagerung der Frequenzen''' angegebenen Code:
Wert = 0
Faktor = 1
Für Detailgrad = 1 bis Rechentiefe
Wert = Wert + InterpolierterWert( Position * Frequenz ) * Faktor
Frequenz = Frequenz * Frequenzfaktor
Faktor = Faktor * Persistenz

[[Bild:PerlinPersistenz.png|center|framed|
''Abb. 3: Unterschiedliche Persitenzen.'' 
''Frequenzfaktor = 2; Rechentiefe = 5'' 
''Links oben: Persistenz 0.2'' 
''Rechts oben: Persistenz 0.4'' 
''Links unten: Persistenz 0.6'' 
''Rechts unten: Persistenz 0.8'']]

==Der Wertebereich==
Bisher wurden zwar in den Bildern die Werte korrekt dargestellt, jedoch wurde noch nicht erklärt wie man zu diesen Werten kommt. Wir möchten nun den Code welcher unter Persistenz angegeben wurde so modifizieren, das er Werte für den Wertebereich [Min|Max] liefert. Betrachten wir vorerst was wir alles verwenden:
*InterpolierterWert( Position * Frequenz ): liefert einen Wert im Bereich [-1|1]
*Faktor: zu Beginn 1, wird bei jeden Durchlauf mit Persistenz multipliziert
*Frequenz und Frequenzfaktor: spielen für die Amplitude keine Rolle
Der Gesamtfaktor lässt sich recht einfach berechnen:
Faktor = 1
GesFaktor = 0
Für Deteilgrad = 1 bis Rechentiefe
GesFaktor = GesFaktor + Faktor
Faktor = Faktor * Persistenz
Mit dem errechneten Gesamtfaktor wissen wir nun, das die Funktion einen Wert im Bereich

[-GesFaktor|+GesFaktor] liefert. Nun brauchen wir nur noch die Amplitude skalieren und einen entsprechenden Offset für das Minimum addieren. Dies sieht im Endeffekt so aus:

Initialisierung:
Bereich = Max - Min;
Offset = Min + Bereich * 0.5;
GesFaktor = 0;
Faktor = 2;

für 1 bis Rechentiefe
GesFaktor += Faktor
Faktor = Faktor * Persistenz

Tiefe_1_Amplitude = Bereich / GesFaktor

Berechnung eines Wertes:
Wert = 0
Faktor = Tiefe_1_Amplitude
Frequenz = 1
Für Detailgrad = 1 bis Rechentiefe
Wert = Wert + InterpolierterWert( Position * Frequenz ) * Faktor
Frequenz = Frequenz * Frequenzfaktor
Faktor = Faktor * Persistenz

Wert = Wert + Offset

= Weiterführendes =
== Einsatzgebiete ==
Neben der Generierung von Texturen und [[Highmap]]s - welche von den Grafiken und Quellcodes in diesem Artikel bevorzugt behandelt wurden - gibt es natürlich noch andere Einsatzgebiete. Einige davon sind:
* Animation, also gehen, Mimik oder jede andere Form von Bewegung kann durch Perlin Noise abwechslungsreicher und somit etwas "menschlicher" gestaltet werden. Der Erfinder Ken Perlin hat hierfür auf seiner [http://mrl.nyu.edu/~perlin/ Homepage] ein paar gute Beispiele.
* Modifikation von Meshes: was bei [[Highmap]]s am offensichtlichesten ist kann man auch auf eine Kugel anwenden um einen wunderbar unregelmäßigen, aber dennoch realistisch wirkenden Stein, Planeten oder einen Kometen daraus zu machen.
* Denkbar wäre die Verwendung von Perlin Noise natürlich auch für verschiedenste Umwelteinflüsse wie Wind (was sich sowohl in Animationen als auch Geräuschlautstärke auswirken kann), aber natürlich auch für künstliche Einflüsse wie Börsenkurse in einem Strategiespiel.

== Erweiterungen ==
Perlin Noise kann (wie nahezu jeder andere Algorithmus auch) nach eigenen Wünschen modifiziert werden. Häufige Modifikationen sind:
* Tilebare Texturen erstellen, also Texturen welche links und rechts - und ggf. auch oben und unten - exakt gleich aussehen. Dieses Problem wird in [http://www.delphigl.com/forum/viewtopic.php?t=3859&postdays=0&postorder=asc&start=15 diesem DGL-Forenthread (ab Seite 2)] etwas näher behandelt.
* Nachbearbeitung der Ausgabewerte. Hier können wir das endgültige Resultat noch sehr stark verändern. Denkbar wäre hier beispielsweise, dass wir die Unterwasser und über Wasser - Landschaft ganz unterschiedlich skalieren. Das eindrucksvollste Beispiel hierfür dürfte jedoch ein Algorithmus für eine [[Himmel]]stextur sein, welcher [http://freespace.virgin.net/hugo.elias/models/m_clouds.htm hier] zu finden ist. Dieser Algorithmus verwendet einfaches Perlin Noise, modifiziert jedoch die Ausgabewerte mit einer Exponentialfunktion, wodurch eine (meines Erachtens) eindrucksvolle Wolkendecke entsteht. Das endgültige Ergebnis des Algorithmus beinhaltet natürlich noch etwas mehr als diese einfache Exponentialfunktion, jedoch könnte man auch dies im weiteren Sinne als Modifikation der Ausgabewerte sehen.

== Verwandte Themen ==
Die Dekomprimierung von JPEG-Bildern basiert auf der Überlagerungen von Cosinus-Schwingungen einer vorgegebenen Frequenz und einer (von Bild zu Bild) variierenden Amplitude. Diese Überlagerung ist sehr ähnlich der Frequenzüberlagerung beim Perlin Noise. Der Unterschied ist natürlich, dass bei JPEG Cosinus Schwingungen verwendet werden und beim Perlin Noise zufällige Werte welche [[Interpolation|interpoliert]] werden.

Die Komprimierung von JPEG-Bildern bildet nun das Gegenteil der Überlagerung von Cosinus-Schwingungen, also der Berechnung der Amplituden der einzelnen Frequenzen. Derartige Berechnungen basieren alle auf der Fourier Transformation.

Also wenn ihr nun verstanden habt wozu die Überlagerung von verschiedenen Frequenzbändern in der Lage ist (wofür dieser Artikel hoffentlich hilfreich war), euch diverse Themen der Mathematik wie integrieren, differenzieren und vor allem Regression nicht allzu sehr abschrecken und ihr immer schon mal wissen wolltet wie derartige Bildkompression oder die Frequenzbalken eurer Audiowidergabe entstehen, wäre wohl nun ein (neuer?) Anlauf vielversprechend.

[[Kategorie:Anleitung]] [[Kategorie:Technik_oder_Algorithmus]]