Tutorial OpenGL3 Zeichenkontext - Versionsgeschichte

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

2014-03-09T11:04:59Z

‎Erstellung eines OpenGL3.x GC

Glawesome: /* Der Grafikcontext */ missverständliche Zeichensetzung korrigiert

2013-11-29T08:30:17Z

‎Der Grafikcontext: missverständliche Zeichensetzung korrigiert

Glawesome: Rechtschreibung, Zeichensetzung...

2013-11-27T21:55:22Z

Rechtschreibung, Zeichensetzung...

Coolcat: /* Verwaltung der veralteten und neuen Funktionen */ => Transform-Feedback korrekt verlinkt

2010-01-10T13:35:49Z

‎Verwaltung der veralteten und neuen Funktionen: => Transform-Feedback korrekt verlinkt

Coolcat: /* Verwaltung der veralteten und neuen Funktionen */

2010-01-09T16:57:04Z

‎Verwaltung der veralteten und neuen Funktionen

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

2009-08-16T13:45:27Z

‎Erstellung eines OpenGL3.x GC

Coolcat: /* Der erste Schritt(Garphic Context) */ Garphic -> OpenGL

2009-08-07T08:57:49Z

‎Der erste Schritt(Garphic Context): Garphic -> OpenGL

TAK2004: Die Seite wurde neu angelegt: „==Der Grafikcontext== Der Grafikcontext (GC) ist die Basis von OpenGL, man kann mehrere GCs in einem Prozess haben, was aber selten Sinn macht. Im GC werden alle …“

2009-08-06T16:00:36Z

Die Seite wurde neu angelegt: „==Der Grafikcontext== Der Grafikcontext (GC) ist die Basis von OpenGL, man kann mehrere GCs in einem Prozess haben, was aber selten Sinn macht. Im GC werden alle …“

Neue Seite

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

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

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

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

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

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

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

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

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

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

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

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

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

PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribsARB = NULL;

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

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

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

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

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

'''X11(Linux/Mac OS)'''
<source lang="cpp">void CreateOpenGL3Context()
{
GLXContex TempContext=glXCreateContext(Display,VisualInfo,NULL,true);//erstellt ein alten OpenGL Context
if (TempContext==NULL)
{
cout<<"Error: Could not create an OpenGL rendering context"<<endl;
return;
}
glXMakeCurrent(Display,Handle,TempContext);//setzt den erstellten GC als aktuellen GC

//Typdefinition von wglCreateContextAttribsARB
typedef HGLRC (APIENTRY * PFNGLXCREATECONTEXTATTRIBSARBPROC)(Display *dpy,GLXFBConfig config,GLXContext share_context,Bool direct,const int *attrib_list);

PFNGLXCREATECONTEXTATTRIBSARBPROC glXCreateContextAttribsARB = NULL;

//abfragen, ob die Funktion existiert
glXCreateContextAttribsARB=(PFNGLXCREATECONTEXTATTRIBSARBPROC)glXGetProcAddress("glXCreateContextAttribsARB");

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

int attribs[]={GLX_CONTEXT_MAJOR_VERSION_ARB,3,GLX_CONTEXT_MINOR_VERSION_ARB,1,GLX_CONTEXT_FLAGS_ARB,GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,0};

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

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

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

@@ Zeile 27: / Zeile 27: @@
 Funktionen, die vom ARB aufgenommen wurden, werden in der Regel mit der kommenden OpenGL Version in den Kern aufgenommen.
-OpenGL3 macht regen Gebrauch von diesen Mechanismen, da viele Kernfunktionen als deprecated markiert wurden und nun über die einzelnen Updates aus dem Kern verschwinden. Da sich der Stand der Technik weiter Entwickelt kommen natürlich auch neue Funktionalitäten hinzu, so z.B. [[Transform Feedback]], [[Instancing]] oder GLSlang 1.4 .
+OpenGL3 macht regen Gebrauch von diesen Mechanismen, da viele Kernfunktionen als deprecated markiert wurden und nun über die einzelnen Updates aus dem Kern verschwinden. Da sich der Stand der Technik weiter Entwickelt kommen natürlich auch neue Funktionalitäten hinzu, so z.B. [[Transform-Feedback]], [[Instancing]] oder GLSlang 1.4 .
 =Der erste Schritt (OpenGL Context)=

@@ Zeile 27: / Zeile 27: @@
 Funktionen, die vom ARB aufgenommen wurden, werden in der Regel mit der kommenden OpenGL Version in den Kern aufgenommen.
-OpenGL3 macht regen Gebrauch von diesen Mechanismen, da viele Kernfunktionen als deprecated markiert wurden und nun über die einzelnen Updates aus dem Kern verschwinden. Da sich der Stand der Technik weiter Entwickelt kommen natürlich auch neue Funktionalitäten hinzu, so z.B. Transform Feedback, Instancing oder GLSlang 1.4 .
+OpenGL3 macht regen Gebrauch von diesen Mechanismen, da viele Kernfunktionen als deprecated markiert wurden und nun über die einzelnen Updates aus dem Kern verschwinden. Da sich der Stand der Technik weiter Entwickelt kommen natürlich auch neue Funktionalitäten hinzu, so z.B. [[Transform Feedback]], [[Instancing]] oder GLSlang 1.4 .
 =Der erste Schritt (OpenGL Context)=

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

@@ Zeile 1: / Zeile 1: @@
 ==Der Grafikcontext==
 Der Grafikcontext (GC) ist die Basis von OpenGL, man kann mehrere GCs in einem Prozess haben, was aber selten Sinn macht.
-Im GC werden alle notwendigen Informationen gehalten, um mit der GPU zu arbeiten, dabei werden Identifier(ID) verwendet, um Resourcen nach außen Verfügbar zu machen. Zu solchen Ressourcen gehören z.B. Texturen, Shader, diverse Buffer Objects und alle werden durch IDs zur Verfügung gestellt.
+Im GC werden alle notwendigen Informationen gehalten, um mit der GPU zu arbeiten. Dabei werden Identifier (ID) verwendet, um Resourcen nach außen verfügbar zu machen. Zu solchen Ressourcen gehören z.B. Texturen, Shader, diverse Buffer Objects und alle werden durch IDs zur Verfügung gestellt.
-Neben den ID-Listen werden noch sogenannte States, Informationen für die Bildausgabe und diverse unbekannte treiberspezifische Daten gespeichert.
+Neben den ID-Listen werden noch sogenannte States - Informationen für die Bildausgabe - und diverse unbekannte treiberspezifische Daten gespeichert.
 ===Profil===
-Um die einzelnen Befehlssätze zu Verwalten hat man sogenannte Profile eingeführt.
+Um die einzelnen Befehlssätze zu verwalten, hat man sogenannte Profile eingeführt.
-OpenGL3 ist z.B. ein Profil, es gibt noch weitere Profile wie z.B. OpenGL3.1 oder OpenGL3.1 Debug.
+OpenGL3 ist z.B. ein Profil, es gibt noch weitere wie z.B. OpenGL3.1 oder OpenGL3.1 Debug.
-Die Profile werden vom ARB fest gelegt und es gibt in der Regel 2 Versionen: Einmal mit Funktionen, die als "deprecated" eingestuft wurden, und einmal mit diesen.
+Die Profile werden vom ARB festgelegt und es gibt in der Regel 2 Versionen: Einmal mit Funktionen, die als "deprecated" eingestuft wurden, und einmal ohne diese.
 ===Forward compatible context und Full context===
-Es gibt 2 Varianten eines Context, der Full context ist enthält alle Funktionen, auch die als deprecated maktierten. Der Forward compatible context enthält nur die nicht als deprecated markierten Funktionen des OpenGL Kerns. Bis zur Version 3.1 gab es immer eine abwärts Kompatibilität und der Treiber hatte entschieden, welche OpenGL Version verwendet werden darf. Mit OpenGL 3.1 gibt es keine abwärts Kompatibilität mehr und man kann festlegen, was für ein GC man haben möchte.
+Es gibt 2 Varianten eines Context, der ''Full context'' enthält alle Funktionen, auch die als deprecated markierten. Der ''Forward compatible context'' enthält nur die nicht als deprecated markierten Funktionen des OpenGL-Kerns. Bis zur Version 3.1 gab es immer eine Abwärtskompatibilität und der Treiber hatte entschieden, welche OpenGL-Version verwendet werden darf. Mit OpenGL 3.1 gibt es keine Abwärtskompatibilität mehr und man kann festlegen, was für einen GC man haben möchte.
 ===Verwaltung der veralteten und neuen Funktionen===
-Das hinzukommen und das entfernen von OpenGL Funktionen unterliegt dem Deprecation und Extension Mechanismus.
+Das Hinzukommen und das Entfernen von OpenGL-Funktionen unterliegt dem Deprecation- und Extension-Mechanismus.
 Diese funktionieren wie folgt.
 '''Deprecation Path''': Core->ARB->Vendor/Extension
-Die Funktion wird erst aus den Bereich der Kernfunktionen entfernt und als ARB zur verfügung gestellt.
+Die Funktion wird erst aus den Bereich der Kernfunktionen entfernt und als ARB zur Verfügung gestellt.
 Dann wird sie aus dem ARB entfernt und als Vendor oder Extension weiter geführt.
 Der Kern wird von der Khronos Group verwaltet, das ARB wird von einer Gruppe bestehend aus AMD/ATI, Nvidia, SGI, Sun, Intel, IBM, Apple, 3DLabs und einigen weiteren zusammen verwaltet und Vendor sowie Extension werden von Firmen wie AMD, Nvidia, SIS und so weiter einzeln verwaltet.
@@ Zeile 24: / Zeile 24: @@
 '''Extension Path''': Vendor/Extension->ARB->Core
-Wenn eine Extension, von einer Firma, vom ARB als sinnvoll angesehen wird, dann wird diese mit aufgenommen.
+Wenn eine Extension von einer Firma, vom ARB als sinnvoll angesehen wird, dann wird diese mit aufgenommen.
-Funktionen, die vom ARB aufgenommen wurden, werden in der Regel mit der kommenden OpenGL Version in den Kern aufgenommen.
+Funktionen, die vom ARB aufgenommen wurden, werden in der Regel mit der kommenden OpenGL-Version in den Kern aufgenommen.
-OpenGL3 macht regen Gebrauch von diesen Mechanismen, da viele Kernfunktionen als deprecated markiert wurden und nun über die einzelnen Updates aus dem Kern verschwinden. Da sich der Stand der Technik weiter Entwickelt kommen natürlich auch neue Funktionalitäten hinzu, so z.B. [[Transform-Feedback]], [[Instancing]] oder GLSlang 1.4 .
+OpenGL3 macht regen Gebrauch von diesen Mechanismen, da viele Kernfunktionen als deprecated markiert wurden und nun über die einzelnen Updates aus dem Kern verschwinden. Da sich der Stand der Technik weiterentwickelt kommen natürlich auch neue Funktionalitäten hinzu, so z.B. [[Transform-Feedback]], [[Instancing]] oder GLSlang 1.4.
 =Der erste Schritt (OpenGL Context)=
-Als erstes wird ein Fenster benötigt, um an dieses unseren GC zu binden. Ich will nicht näher auf die Erstellung eines Fensters eingehen, da dies nicht das Thema dieses Artikels ist und verweise auf den Democode am Ende des Artikels. Sobald das Fenster erstellt ist, können wir uns darum kümmern einen passenden GC zu erstellen. Hierzu brauchen wir erstmal Informationen, vom Desktop Manager, welche Möglichkeiten wir überhaupt zur Auswahl haben. Es wird ein Double Buffer benötigt und man muss die Farbtiefe sowie Tiefenpuffer Genauigkeit festlegen. Dies wird von den Desktop Managern unterschiedlich gehandhabt, so hat Windows z.B. ein DeviceContext und ein Pixelformat und X11 nennt dies VisualInfo bzw. GLXFBConfig.
+Als erstes wird ein Fenster benötigt, um an dieses unseren GC zu binden. Ich will nicht näher auf die Erstellung eines Fensters eingehen, da dies nicht das Thema dieses Artikels ist und verweise auf den Democode am Ende des Artikels. Sobald das Fenster erstellt ist, können wir uns darum kümmern, einen passenden GC zu erstellen. Hierzu brauchen wir erstmal Informationen vom Desktop Manager, welche Möglichkeiten wir überhaupt zur Auswahl haben. Es wird ein [[Doppelpufferung|Double Buffer]] benötigt und man muss die Farbtiefe sowie Genauigkeit des [[Tiefenpuffer]]s festlegen. Dies wird von den Desktop Managern unterschiedlich gehandhabt, so hat Windows z.B. ein DeviceContext und ein Pixelformat und X11 nennt dies VisualInfo bzw. GLXFBConfig.
-Ist dieser Schritt getan kann man nun einen alten OpenGL Context erstellen, prüfen ob die ARB Funktion vorhanden ist und dann versuchen einen OpenGL3.x Context zu erstellen.
+Ist dieser Schritt getan, kann man nun einen alten OpenGL Context erstellen, prüfen ob die ARB Funktion vorhanden ist und dann versuchen einen OpenGL3.x Context zu erstellen.
 ==Erstellung eines OpenGL3.x GC==
-Um ein GC ertellen zu können wird eine weitere API benötigt, welche plattformabhängig und durch wgl[Funktionsname]/glX[Funktionsname] erkennbar ist. Mit diesen Befehlen kann man mit den Windows und X11 Desktop Manager zusammen arbeiten. So werden Funktionen für das erstellen, wechseln, zerstören eines GC, laden von Extension, wechseln des Fensterpuffern und Synchronisieren von CPU und GPU ermöglicht. Bisher gibt es noch keine Möglichkeit einen OpenGL3 fähigen GC zu erstellen, ohne dafür eine Funktion vom ARB zu verwenden. Der Nachteil von ARB Funktionen sind, dass man einen gültigen GC benötigt den Zeiger auf diese zu erhalten. Um einen OpenGL 3.0 oder 3.1 GC zu erstellen benötigt man einen OpenGL1-2 GC und die Kernfunktion [[wglGetProcAddress]]/[[glxGetProcAddress]]. Einen gültigen OpenGL1 bzw. OpenGL2 GC bekommt man über den Befehl [[wglCreateContext]]/[[glxCreateContext]] und zwischen mehreren GC kann man mit dem Befehl [[wglMakeCurrent]]/[[glxMakeCurrent]] wechseln.
+Um einen GC ertellen zu können, wird eine weitere API benötigt, welche plattformabhängig und durch wgl[Funktionsname]/glX[Funktionsname] erkennbar ist. Mit diesen Befehlen kann man mit den Windows und X11 Desktop Manager zusammenarbeiten. So werden Funktionen für das Erstellen, Wechseln, Zerstören eines GC, Laden von Extensions, Wechseln des Fensterpuffers und Synchronisieren von CPU und GPU ermöglicht. Bisher gibt es noch keine Möglichkeit, einen OpenGL3 fähigen GC zu erstellen, ohne dafür eine Funktion vom ARB zu verwenden. Der Nachteil von ARB Funktionen ist, dass man einen gültigen GC benötigt, um den Zeiger auf diese zu erhalten. Um einen OpenGL 3.0 oder 3.1 GC zu erstellen, benötigt man einen OpenGL1-2 GC und die Kernfunktion [[wglGetProcAddress]]/[[glxGetProcAddress]]. Einen gültigen OpenGL1 bzw. OpenGL2 GC bekommt man über den Befehl [[wglCreateContext]]/[[glxCreateContext]] und zwischen mehreren GC kann man mit dem Befehl [[wglMakeCurrent]]/[[glxMakeCurrent]] wechseln.
-Der Befehl für die Erstellung eines OpenGL3 fähigen GC heisst [[wglCreateContextAttribsARB]]/[[glxCreateContextAttribsARB]].
+Der Befehl für die Erstellung eines OpenGL3-fähigen GC heißt [[wglCreateContextAttribsARB]]/[[glxCreateContextAttribsARB]].
-Mit OpenGL3.2 soll eine Funktion in den OpenGL Kern kommen, welcher es erlaubt einen OpenGL3 und aufwärts fähigen GC zu erstellen, ohne einen älteren GC vorher zu erstellen. Dies wird erreicht, in dem man die noch jetzige ARB Funktion in den OpenGL-Kern mit aufnimmt und somit das erfragen der ARB Funktion, über ein OpenGL1-2GC, unnötig macht.
+Mit OpenGL3.2 soll eine Funktion in den OpenGL Kern kommen, welcher es erlaubt einen OpenGL3 und aufwärts fähigen GC zu erstellen, ohne einen älteren GC vorher zu erstellen. Dies wird erreicht, indem man die noch jetzige ARB Funktion in den OpenGL-Kern mit aufnimmt und somit das Erfragen der ARB Funktion, über ein OpenGL1-2GC, unnötig macht.
 '''Windows'''
@@ Zeile 85: / Zeile 85: @@
 }</source>
-Mac OS erlaubt die nachträgliche Installation von X11 und kann somit über die folgenden Code ebenfalls ein OpenGL Context erstellen. Alternativ bietet Mac OS mehrere OpenGL Schnittstellen, welche sich in der Einfachheit der API unterscheiden. Wenn man nicht den Nutzer zwingen will X11 zu installieren, dann sollte man zu den entsprechenden Schnittstellen AGL, CGL oder NSOpenGL greifen.
+Mac OS erlaubt die nachträgliche Installation von X11 und kann somit über den folgenden Code ebenfalls einen OpenGL Context erstellen. Alternativ bietet Mac OS mehrere OpenGL Schnittstellen, welche sich in der Einfachheit der API unterscheiden. Wenn man nicht den Nutzer zwingen will X11 zu installieren, dann sollte man zu den entsprechenden Schnittstellen AGL, CGL oder NSOpenGL greifen.
 '''X11(Linux/Mac OS)'''

@@ Zeile 84: / Zeile 84: @@
    wglDeleteContext(TempContext);//Zerstöre den temporären Context, denn er wird nicht länger benötigt.
 }</source>
 '''X11(Linux/Mac OS)'''
-<source lang="cpp">void CreateOpenGL3Context()
+<source lang="cpp">  bool OpenGLWindow::CreateOpenGL3Context()
+   {
-     cout<<"Error: Could not create an OpenGL rendering context"<<endl;
+     GLXContext TempContext=glXCreateContext(m_Display,m_VisualInfo,0,GL_TRUE);//erstellt ein alten OpenGL Context
-    return;
+    if(TempContext==0)
-−
+    {
-  glXMakeCurrent(Display,Handle,TempContext);//setzt den erstellten GC als aktuellen GC
+      cerr<<"Error: Could not create an OpenGL rendering context."<<endl;
-  //Typdefinition von wglCreateContextAttribsARB
+    //Typdefinition von wglCreateContextAttribsARB
-  typedef HGLRC (APIENTRY * PFNGLXCREATECONTEXTATTRIBSARBPROC)(Display *dpy,GLXFBConfig config,GLXContext share_context,Bool direct,const int *attrib_list);
+    typedef GLXContext (* GLXCREATECONTEXTATTRIBSARBPROC)(Display *dpy,GLXFBConfig config,GLXContext share_context,Bool direct,const int *attrib_list);
-  PFNGLXCREATECONTEXTATTRIBSARBPROC glXCreateContextAttribsARB = NULL;
+    if(glXCreateContextAttribsARB == NULL)//wenn es diese Funktion nicht gibt, dann hat der -->Treiber<-- keinen OpenGL3 support
-−
+    {
-  //abfragen, ob die Funktion existiert
+      cerr<<"Error: There is no OpenGL3 context support."<<endl;
-  glXCreateContextAttribsARB=(PFNGLXCREATECONTEXTATTRIBSARBPROC)glXGetProcAddress("glXCreateContextAttribsARB");
+      return false;
-−
+    }
-  if(glXCreateContextAttribsARB == NULL)//wenn es diese Funktion nicht gibt, dann hat der -->Treiber<-- keinen OpenGL3 support
+    int minor=0;
+    int major=0;
-    glXDeleteContext(TempContext);
+    glGetIntegerv(GL_MAJOR_VERSION,&major);
-    cerr<<"Error: There is no OpenGL3 context support."<<endl;
+    glGetIntegerv(GL_MINOR_VERSION,&minor);
-    return;
+    int attribs[]={GLX_CONTEXT_MAJOR_VERSION_ARB,major,GLX_CONTEXT_MINOR_VERSION_ARB,minor,GLX_CONTEXT_FLAGS_ARB,GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,0};
+    for (int i=minor; i>=0;i--)
+     {
-       //Die -->Grafikkarte<-- beherrscht kein OpenGL3.
+       attribs[3]=i;//Setze minor version auf 0 um ein OpenGL3.0 context zu erstellen.
-      glXDeleteContext(TempContext);//aufräumen und beenden
+      m_Context=glXCreateContextAttribsARB(m_Display, m_FBConfig[0], NULL, true, attribs);
-      cerr<<"Error: Couldn't create OpenGL3 context."<<endl;
+      if (!m_Context)//versuche ein OpenGL3.i fähigen Context zu erstellen
-       return;
+     }
+   }
 }</source>