Files |  Tutorials |  Articles |  Links |  Home |  Team |  Forum |  Wiki |  Impressum

Aktuelle Zeit: Mi Jul 16, 2025 17:14

Foren-Übersicht » Programmierung » Allgemein
Unbeantwortete Themen | Aktive Themen



Ein neues Thema erstellen Auf das Thema antworten  [ 24 Beiträge ]  Gehe zu Seite Vorherige  1, 2
Autor Nachricht
 Betreff des Beitrags:
BeitragVerfasst: Fr Feb 24, 2006 10:53 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 05, 2002 10:35
Beiträge: 4234
Wohnort: Dortmund
Ist wie gesagt wirklich nicht böse gemeint. Waren nur ein paar Ideen um es kompatibler zu gestalten und evtl Schwachstellen aufzudecken. Diverse Eigenarten und vorgehensweisen mit den Extensions lernt man ja auch nur wenn man es gesagt bekommt oder irgendwo auf die Nase fällt.

Die Verfügbarkeit der Extension ist bei jedem System immer anders. Für jede Extension haben wir im Header eine Booleanvariable eingefügt mit der du abfragen kannst ob die Extension verfügbar ist oder nicht. In diesem Falle WGL_ARB_pixel_format. Diese Variablen werden durch ActivateRenderContext oder ReadImplementationProperties mit leben gefüllt. Die Funktionspointer werden entweder auch durch ActivateRenderContext (Dritte Parameter True) oder durch Read_Extensionname geladen.

Bei einige Extension gibt es Alternativen bei einigen Anderen wiederrum nicht. Multisampling ist da eher ein nettes Gimick welches aber nicht zwingend notwendig ist. Wobei ich das bei mir in einem Rutsch gemacht habe. Also zu erst Normal den Kontext initialisieren und dann abgeprüft ob Multisampling vorhanden ist. Pixelformat ausgewählt und wenn alles Okay war, dann habe ich Kontext, DC und Fenster gelöscht und neu angelegt. Wenns nicht in Ordnung ist wird einfach nur bestimmter Code nicht ausgeführt. Dabei läuft das Programm liniear ab was nicht ganz so verwirrend ist. Denke ich. ;-)

Bin auf jeden Fall noch gespannte was du noch so alles raus findest. :-)


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Feb 24, 2006 21:25 
Offline
DGL Member

Registriert: Mi Feb 22, 2006 10:41
Beiträge: 12
Wohnort: St. Gallen - Schweiz
So, nun hab ich's. Einen schönen Code mit Fallback und vielen Kommentaren, damit jeder versteht, was warum gemacht wird.

Wenn ihr Fehler im Code findet oder Verbesserungsvorschläge habt, dann schreibt es doch einfach in dieses Forum oder schickt mir eine PN, oder was auch immer...

Um das ganze recht simpel zu machen, habe ich einfach alles in FormCreate gepackt. Schöner und übersichtlicher ist's selbstverständlich wenn man die ganze OpenGL-Initialisierung in eine eigene Prozedur steckt.

Ich habe den Code selbst auf mehreren Multisample-unterstütztenden und auch auf mehreren nicht-Multisample-unterstützenden Grafikkarten getestet und es hat bis jetzt immer einwandfrei geklappt. Keine Fehlermeldungen, wenn Multisample unterstützt wird, wird's implementiert und sonst wird halt das Fallback-Pixelformat verwendet.

Nun aber genug geschrieben, hier ist der Code:

Code:
  1. unit Unit1;
  2.  
  3. interface
  4.  
  5. uses
  6.   Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  7.   Dialogs, dglOpenGL;
  8.  
  9. type
  10.   TForm1 = class(TForm)
  11.     procedure FormCreate(Sender: TObject);
  12.     procedure MyError(code: Integer);
  13.   private
  14.     { Private declarations }
  15.   public
  16.     { Public declarations }
  17.   end;
  18.  
  19. var
  20.   Form1: TForm1;
  21.   DC: HDC;
  22.   RC: HGLRC;
  23.  
  24.   implementation
  25.  
  26. {$R *.dfm}
  27.  
  28. procedure TForm1.FormCreate(Sender: TObject);
  29. var
  30.   //Pixelformat-Beschreibung, für den Fall, dass keine Multisample-Extensions
  31.   //verfügbar sind
  32.   FallBackPFD: TPixelFormatDescriptor;
  33.   //FallBack-PixelFormat, wenn kein Multisample-PF verfügbar ist
  34.   FallBackPF: GLInt;
  35.   //Multisample-PF, das schlussendlich gesetzt wird / Anzahl der gefundenen PFs
  36.   MultiPF, numPFs: GLInt;
  37.   //wird Multisampling von ARB bzw. EXT unterstützt?
  38.   multiARBSup, multiEXTSup: Boolean;
  39.   //Interger-Attribute für das Multisample-PF
  40.   IAtrib: array[0..18] of GLInt;
  41.   //Float-Attribute für das Multisample-PF
  42.   FAtrib: GLFloat;
  43.   //temprärer Device Context um Multisample-PF zu finden
  44.   tmpDC: HDC;
  45.   //Array, in den alle gefundenen Multisample-PFs gespeichert werden
  46.   possiblePFs: array[0..63] of GLInt;
  47.   //Eigenschaft, die überprüft werden soll / Variable, in die das Resultat
  48.   //gespeichert wird
  49.   QueryIAtrib, ResultIAtrib: GLInt;
  50.   //Zähl-Variable / höchst gefundene Anzahl unterstützte Samples (je mehr
  51.   //Samples benutzt werden, desto besser ist das Anti-Aliasing
  52.   i, highestSamp: Integer;
  53. begin
  54.   //OpenGL normal initialisieren und Device-Context holen
  55.   if not InitOpenGL then
  56.     MyError(1);
  57.  
  58.   DC := GetDC(Handle);
  59.   if DC = 0 then
  60.     MyError(2);
  61.  
  62.   //FallBack-Pixelformat definieren und setzen
  63.   with FallBackPFD do
  64.   begin
  65.     nSize := SizeOf(FallBackPFD);
  66.     nVersion := 1;
  67.     dwFlags := PFD_DRAW_TO_WINDOW or PFD_SUPPORT_OPENGL or PFD_DOUBLEBUFFER;
  68.     iPixelType := PFD_TYPE_RGBA;
  69.     cColorBits := 32;
  70.     cDepthBits := 24;
  71.   end;
  72.   FallBackPF := ChoosePixelFormat(DC,@FallBackPFD);
  73.   if FallBackPF = 0 then
  74.     MyError(5);
  75.   if not SetPixelFormat(DC,FallBackPF,@FallBackPFD) then
  76.     MyError(6);
  77.  
  78.   //Render-Context erstellen und aktivieren
  79.   RC := wglCreateContext(DC);
  80.   if RC = 0 then
  81.     MyError(3);
  82.   if not wglMakeCurrent(DC,RC) then
  83.     MyError(4);
  84.  
  85.   //auslesen, welche Extensions verfügbar sind
  86.   ReadImplementationProperties;
  87.  
  88.   //überprüfen, ob die Extensions verfügbar sind und Exensions laden
  89.   multiARBSup := false;
  90.   multiEXTSup := false;
  91.   if WGL_ARB_extensions_string and WGL_ARB_pixel_format
  92.       and (WGL_ARB_MULTISAMPLE or GL_ARB_MULTISAMPLE) then
  93.       multiARBSup := true;
  94.     if WGL_EXT_extensions_string and WGL_EXT_pixel_format
  95.       and (WGL_EXT_MULTISAMPLE or GL_EXT_MULTISAMPLE) then
  96.       multiEXTSup := true;
  97.   if multiARBSup then
  98.     Read_WGL_ARB_pixel_format
  99.   else if multiEXTSup then
  100.     Read_WGL_EXT_pixel_format;
  101.  
  102.   //wenn Multisampling unterstützt wird, soll es auch implementiert werden
  103.   if multiARBSup or multiEXTSup then
  104.   begin
  105.     //Integer-Attribute setzten, das letzte Element muss 0 sein
  106.     IAtrib[0] := WGL_DRAW_TO_WINDOW_ARB;
  107.     IAtrib[1] := 1;
  108.     IAtrib[2] := WGL_SUPPORT_OPENGL_ARB;
  109.     IAtrib[3] := 1;
  110.     IAtrib[4] := WGL_DOUBLE_BUFFER_ARB;
  111.     IAtrib[5] := 1;
  112.     IAtrib[6] := WGL_PIXEL_TYPE_ARB;
  113.     IAtrib[7] := WGL_TYPE_RGBA_ARB;
  114.     IAtrib[8] := WGL_COLOR_BITS_ARB;
  115.     IAtrib[9] := 24;
  116.     IAtrib[10] := WGL_ALPHA_BITS_ARB;
  117.     IAtrib[11] := 0;
  118.     IAtrib[12] := WGL_DEPTH_BITS_ARB;
  119.     IAtrib[13] := 24;
  120.     IAtrib[14] := WGL_STENCIL_BITS_ARB;
  121.     IAtrib[15] := 0;
  122.     IAtrib[16] := WGL_SAMPLE_BUFFERS_ARB;
  123.     IAtrib[17] := 1;
  124.     IAtrib[18] := 0;
  125.  
  126.     //Float-Attribute setzten, das letzte (und hier einzige) Element muss 0 sein
  127.     FAtrib := 0;
  128.  
  129.     //temporärer Device Context erstellen
  130.     tmpDC := wglGetCurrentDC;
  131.  
  132.     //Multisample-PF suchen und überprüfen ob mindestens eins gefunden wurde
  133.     if multiARBSup then
  134.       wglChoosePixelFormatARB(tmpDC,@IAtrib,@FAtrib,Length(possiblePFs),
  135.         @possiblePFs,@numPFs)
  136.     else if multiEXTSup then
  137.       wglChoosePixelFormatEXT(tmpDC,@IAtrib,@FAtrib,Length(possiblePFs),
  138.         @possiblePFs,@numPFs);
  139.     //wenn kein Multisample-PF gefunden wurde, Prozedur einfach verlassen,
  140.     //das Fallback-PF wurde ja bereits gesetzt
  141.     if numPFs = 0 then
  142.       exit;
  143.  
  144.     //in possiblePFs sind jetzt alle Multisample-PFs gespeichert, es muss jetzt
  145.     //noch dasjenige, welches am meisten Samples unterstützt, gefunden werden
  146.     QueryIAtrib := WGL_SAMPLES_ARB;
  147.     highestSamp := 0;
  148.     MultiPF := 0;
  149.     for i:=0 to Length(possiblePFs)-1 do
  150.     begin
  151.       //WGL_SAMPLES_ARB aus dem aktuellen PixelFormat herauslesen
  152.       if multiARBSup then
  153.         wglGetPixelFormatAttribivARB(tmpDC,possiblePFs[i],0,1,@QueryIAtrib,
  154.           @ResultIAtrib)
  155.       else if multiARBSup then
  156.         wglGetPixelFormatAttribivEXT(tmpDC,possiblePFs[i],0,1,@QueryIAtrib,
  157.           @ResultIAtrib);
  158.       //wenn die Sample-Anzahl höher ist, als bisher, dann neue setzen
  159.       if ResultIAtrib > highestSamp then
  160.       begin
  161.         highestSamp := ResultIAtrib;
  162.         MultiPF := possiblePFs[i];
  163.       end;
  164.     end;
  165.  
  166.     //in MultiPF steht jetzt die ID des Multisample-PF, das am meisten Samples
  167.     //unterstützt, also muss dieses nur noch auf das Fenster gesetzt werden.
  168.     //Das Problem ist nur, dass das Fenster bereits ein PF hat und man darf
  169.     //daher kein neues setzen. Das vorhandene Fenster muss also zerstört und
  170.     //wieder erstellt werden, dann kann das Multisample-PF gesetzt werden
  171.     Form1.DestroyWnd;
  172.     Form1.CreateWnd;
  173.  
  174.     //neues Fenster inizialisieren und Device-Context holen
  175.     DC := GetDC(Handle);
  176.     if DC = 0 then
  177.       MyError(2);
  178.  
  179.     //MultisamplePF setzten, falls dies fehlschlägt, FallBackPF setzten
  180.     if not SetPixelFormat(DC,MultiPF,nil) then
  181.       if not SetPixelFormat(DC,FallBackPF,@FallBackPFD) then
  182.         MyError(6);
  183.  
  184.     //Render-Context erstellen und aktivieren
  185.     RC := wglCreateContext(DC);
  186.     if RC = 0 then
  187.       MyError(3);
  188.     if not wglMakeCurrent(DC,RC) then
  189.       MyError(4);
  190.   end;
  191. end;
  192.  
  193. //MyError zeigt eine Fehlermeldung an, der Text wird je nach Code generiert.
  194. //Nachdem der Benutzer auf den OK-Button der Fehlermeldung geklickt hat, wird
  195. //das Programm beendet.
  196. procedure TForm1.MyError(code: Integer);
  197. var
  198.   ErrStr: string;
  199. begin
  200.   case code of
  201.     1: ErrStr := 'Initializing OpenGL';
  202.     2: ErrStr := 'Getting Device Context';
  203.     3: ErrStr := 'Creating Rendering Context';
  204.     4: ErrStr := 'Activating Rendering Context';
  205.     5: ErrStr := 'Initializing Pixelformat';
  206.     6: ErrStr := 'Setting Pixelformat';
  207.   end;
  208.   ErrStr := ErrStr + ' faild! Application terminated!';
  209.   MessageDlg(ErrStr,mtError,[mbOK],0);
  210.   Application.Terminate;
  211. end;
  212.  
  213. end.


Ich habe aber auch noch eine kleine Frage: Wenn eine Grafikkarte weder WGL_ARB_MULTISAMPLE noch WGL_EXT_MULTISAMPLE unterstützt, gibt es dann (ausser mit Accumulation-Buffer) noch ne andere Variante um hübsches Anti-Aliasing hinzukriegen? Und wie würde die Accumulation-Methode genau funktionieren?

Grüsse
Gamer 2000


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mo Feb 27, 2006 09:53 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 05, 2002 10:35
Beiträge: 4234
Wohnort: Dortmund
Sorry. Hat nen bisschen gedauert. Also ich finden den Code wirklich gut. Sehr gute arbeit. :-) Habe aber noch ein paar Anmerkungen.

Du suchst die Liste mit den PixelFormaten und suchst nach dem mit der höchsten Sampleanzahl. Das finde ich nicht ganz so glücklich. Mitunter benutze ich bei einigen Spielen bewusst nur 2 oder 4faches Antialising. Da es eben ein bisschen Leistungshungrig ist und man so mitunter leistung einsparen kann. Besonders bei modernen Spielen ist mein Rechner mitunter ein bisschen überfordert. Ich denke es wäre da besser wenn man sagt 2fach und er macht es oder lässt es. Zu herrausfinden was überhaupt unterstützt wird ist das aber sicherlich schon eine sehr sinnvolle Möglichkeit.

Eine andere Sache wäre, dass man auch noch evtl Texturen laden muss oder diverse Einstellungen tätigen muss. Wenn du zwischendrin in der Methode ein Exit aufrufst dann gelangt man nicht in die Initialisierung die sich unter der Kontexterstellung befindet. Der alte Kontext existiert zu diesem Zeitpunkt ja noch. Das bedeutet, dass OpenGL ja auf jeden Fall funktioniert.

Evtl wäre es praktisch, wenn du vor dem DestroyWnd noch den Kontext und den DC zerstörst / Freigibst. Ist zwar normal nicht zwingend notwendig aber besser wäre es bestimmt, wenn man alles freigibt was man sich geholt hat. Ich traue Windows da nur so weit wie ich einen Konzertflügel werfen kann.

PS: Ich hoffe du verstehst meine Anmerkungen nicht als Kritik. Ich neige manchmal unter Umständen ein bisschen zu Perfektionissmus ... und Untertreibungen. ;-)

Accumulation: Im RedBook stand dazu glaube ich etwas. Aber das würde ich persönlich nicht machen. Das ist wohl nur gefaked da das echte Antializing da sogar nur Pixelzwischenschritte nimmt und nicht wie der Buffer als kleinsten Schritt ein Pixel kennt. Muss aber gestehen, dass ich das vor ner halben Ewigkeit mal gelesen habe und mittlerweile es nicht mehr genau weiß. Um ehrlich zu sein ist die Erinnerung daran ziemlich verblasst. Ich denke mal, dass man da Heutzutage eher mit FramebufferObject oder Ala RenderToTexture mehr erreichen kann. Aber auch das wird wahnsinnig Langsam. Und auf Karten die kein Multisampling unterstützen dürfte das der absolute Overkill sein. ;-)


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mo Feb 27, 2006 10:06 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 05, 2002 10:35
Beiträge: 4234
Wohnort: Dortmund
Holzauge sei Wachsam. Ist mir doch zum Accumulationbuffer noch was eingefallen. Humus hatte bei sich auf der Seite vor einer Weile eine Supersampling Demo. Dabei löst er das mit dem Accumbuffer und durch leichtes verändern der Projection. Dabei wird aber eine Szene bis zu 11 Mal gezeichnet. Was natürlich schon recht häftig ist. Ist natürlich die Frage wie schnell es wäre, wenn man in ein FramebufferObject rendern und dieses dann nur 11 Mal an leicht unterschiedlichen Stellen rendert. Das sollte eigentlich schneller gehen als die komplette Szene 11 Mal zu rendern. Was sich speziell bei sehr großen Szenen bemerkbar machen dürfte. Aber ob es dadurch Praxistauglicher wird wage ich zu bezweifeln.

PS: Seine neuste Demo ist zwar DX und benötigt Shader Model 3. Aber dabei hat er einen Selectives Supersampling eingebaut.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mo Feb 27, 2006 19:01 
Offline
DGL Member

Registriert: Mi Feb 22, 2006 10:41
Beiträge: 12
Wohnort: St. Gallen - Schweiz
Erst mal Danke für die Infos über den Accumulationbuffer.

Anzahl der Samples
Wenn mein Projekt dann mal fertig ist, stelle ich mir das folgendermassen vor: Wenn das Programm zum ersten Mal ausgeführt wird, werden alle unterstützten Sample-Anzahlen ausgelesen und in ein Konfigurations-File (ini oder xml) geschrieben. Der Benutzen kann dann auswählen, wie viele Samples er haben möchte, natürlich stehen ihm nur die unterstützten Samples zur Verfügung.
Ich wollte hier eigentlich nur die Methode zum Auslesen der unterstützten Samples zeigen, wie man es dann schlussendlich macht, ist jedem selbst überlassen.

exit
Ich bin mir des exit-Problems in diesem Code-Beispiel voll bewusst, aber ich entschied mich, es trotzdem so zu lassen, weil ich einen möglichst simplen Code posten wollte, der nur das Grundgerüst darstellt. In meinem Programm ist das, was hier bei FormCreate ausgefürht wird, in einer Unterprozedur (InitializeWindow) der Prozedur InitializeOpenGL. InitializeOpenGL führt zuerst InitializeWindow aus und dann folgen weitere Prezeduren, wie Einstellungen initialisieren, Projektionsmatrix initialisieren, Lichter, Materialen, Texturen initialisieren bzw. laden etc.
Wenn also das exit nur in einer Unterprozedur ist, nach der alle anderen Dinge initialisiert werden, stellt es kein Problem mehr dar.

Und noch zum Schluss: Ich verstehe Deine Anmerkungen durchaus als Kritik :wink:, aber selbstverständlich als konstruktive Kritik und die ist fast immer angebracht... genauso wie Perfektionismus...


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Do Mär 30, 2006 16:35 
Offline
DGL Member

Registriert: Mi Mär 22, 2006 18:26
Beiträge: 17
Wohnort: Halle, Sachsen-Anhalt
Die Idee mit dem zerstören und anschließendem Wiedererstellen des Fensters ist gut. Man könnte sie aber umgehen. Bei vielen Spielen sieht man ein Launch-Programm, in dem man z.B. die Auflösung einstellt, den Treiber auswählt etc. Eine Möglichkeit wäre es also, über ein solches Programm die ID des Pixelformates auszulesen bzw. gleich alle wichtigen Einstellungen zu treffen. Dabei wird das Fenster des Launchers zum Ermitteln der PixelFormate genutzt und das eigentliche Darstellungsprogramm übernimmt es. Da beim Start immer erst der Launcher erscheint, könnte man so auch auf geänderte Grafikkarten / PixelFormat IDs zugreifen.

_________________
"Wer nicht arbeitet, kann auch nichts falsch machen"


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Sa Apr 29, 2006 12:25 
Offline
DGL Member
Benutzeravatar

Registriert: Do Sep 02, 2004 19:42
Beiträge: 4158
Programmiersprache: FreePascal, C++
Sorry, wenn ich den Thread jetzt aus seiner leichten Versekung hole, aber ich habe den Pixel-Format-Sucher mal in eine Funktion geschrieben, sodass man nicht selber das Fenster zerstören und wieder neu erstellen muss.

Diese Funktion erstellt ein tempräres Fenster, sucht nach einem Multisample PF und gibt dieses dann zurück. Für den Fall, dass kein Multisample unterstützt wird, wird ein einfaches PF zurückgegeben.

Code:
  1. function GetMultisamplePixelFormat: TGLUInt;
  2. var
  3.   Form: TForm;
  4.   RC: HGLRC;
  5.   DC: HDC;
  6.   IAtrib: array[0..20] of TGLUInt;
  7.   FAtrib: TGLFloat;
  8.   PixelFormat: array[0..64] of TGLUInt;
  9.   numPixelFormats, tmpDC: TGLUInt;
  10.   pfd: TPixelFormatDescriptor;
  11.   Buf: TGLUInt;
  12. begin
  13.   Form := TForm.Create(nil);
  14.   DC := GetDC(Form.Handle);
  15.   RC := CreateRenderingContext(DC, [opDoubleBuffered], 24, 24, 0, 0, 0, 0);
  16.  
  17.  
  18.   with pfd do
  19.   begin
  20.     nSize := SizeOf(TPixelFormatDescriptor);
  21.     nVersion := 1;
  22.     dwFlags := PFD_DRAW_TO_WINDOW
  23.       or PFD_SUPPORT_OPENGL
  24.       or PFD_DOUBLEBUFFER;  
  25.     iPixelType := PFD_TYPE_RGBA;
  26.     cColorBits := 24;
  27.     cAlphaBits := 0;
  28.     cDepthBits := 24;
  29.     cStencilBits := 0;
  30.   end;
  31.   Buf := ChoosePixelFormat(DC, @pfd);
  32.   if Buf = 0 then
  33.   begin
  34.     MessageDlg('OpenGL not supported! Please install a NEW graphics driver!', mtError, [mbOK], 0);
  35.     if RC<>0 then
  36.     begin
  37.       if (not wglMakeCurrent(DC,0)) then
  38.         MessageDlg('Rendering Context konnte nicht abgewählt werden.', mtError, [mbOk], 0);
  39.       if (not wglDeleteContext(RC)) then
  40.         MessageDlg('Rendering Context konnte nicht freigegeben werden.', mtError, [mbOk], 0)
  41.     end;
  42.     Form.Destroy;
  43.     Application.Terminate;
  44.   end;
  45.   SetPixelFormat(DC, Buf, @pfd);
  46.  
  47.   IAtrib[0] := WGL_DRAW_TO_WINDOW_ARB;
  48.   IAtrib[1] := 1;
  49.   IAtrib[2] := WGL_SUPPORT_OPENGL_ARB;
  50.   IAtrib[3] := 1;
  51.   IAtrib[4] := WGL_DOUBLE_BUFFER_ARB;
  52.   IAtrib[5] := 1;
  53.   IAtrib[6] := WGL_PIXEL_TYPE_ARB;
  54.   IAtrib[7] := WGL_TYPE_RGBA_ARB;
  55.   IAtrib[8] := WGL_COLOR_BITS_ARB;
  56.   IAtrib[9] := 24;
  57.   IAtrib[10] := WGL_ALPHA_BITS_ARB;
  58.   IAtrib[11] := 8;
  59.   IAtrib[12] := WGL_DEPTH_BITS_ARB;
  60.   IAtrib[13] := 24;
  61.   IAtrib[14] := WGL_STENCIL_BITS_ARB;
  62.   IAtrib[15] := 0;
  63.   IAtrib[16] := WGL_SAMPLE_BUFFERS_ARB;
  64.   IAtrib[17] := 1;
  65.   IAtrib[18] := WGL_SAMPLES_ARB;
  66.   IAtrib[19] := 6;
  67.   IAtrib[20] := 0;
  68.  
  69.   FAtrib := 0;
  70.  
  71.   if not wglMakeCurrent(DC,RC) then
  72.   begin
  73.     MessageDlg('Couldn''t enable rendering context', mtError, [mbOK], 0);
  74.     if RC<>0 then
  75.     begin
  76.       if (not wglMakeCurrent(DC,0)) then
  77.         MessageDlg('Rendering Context konnte nicht abgewählt werden.', mtError, [mbOk], 0);
  78.       if (not wglDeleteContext(RC)) then
  79.         MessageDlg('Rendering Context konnte nicht freigegeben werden.', mtError, [mbOk], 0)
  80.     end;
  81.     Form.Destroy;
  82.     Application.Terminate;
  83.   end;
  84.  
  85.  
  86.  
  87.   wglChoosePixelFormatARB(DC,@IAtrib,@FAtrib,length(PixelFormat),
  88.     @PixelFormat,@numPixelFormats);
  89.  
  90.   if numPixelFormats = 0 then
  91.   begin
  92.     Result := Buf;
  93.   end
  94.   else
  95.     Result := PixelFormat[0];
  96.  
  97.   if RC<>0 then
  98.   begin
  99.     if (not wglMakeCurrent(DC,0)) then
  100.       MessageDlg('Rendering Context konnte nicht abgewählt werden.', mtError, [mbOk], 0);
  101.     if (not wglDeleteContext(RC)) then
  102.       MessageDlg('Rendering Context konnte nicht freigegeben werden.', mtError, [mbOk], 0)
  103.   end;
  104. end;


Ich hoffe, das ist hilfreich.

Gruß Lord Horazont

[WIKITASTISCH]

_________________
If you find any deadlinks, please send me a notification – Wenn du tote Links findest, sende mir eine Benachrichtigung.
current projects: ManiacLab; aioxmpp
zombofant networkmy photostream
„Writing code is like writing poetry“ - source unknown


„Give a man a fish, and you feed him for a day. Teach a man to fish and you feed him for a lifetime. “ ~ A Chinese Proverb


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Aug 07, 2009 12:49 
Offline
Guitar Hero
Benutzeravatar

Registriert: Do Sep 25, 2003 15:56
Beiträge: 7810
Wohnort: Sachsen - ERZ / C
Programmiersprache: Java (, Pascal)
Da Lossy gerade auf diesen Beitrag von Lord Horazont verwiesen hat:

Wurde dieser Code bereits im Wiki zur Verfügung gestellt?

Wenn nein, wieso nicht? 8)

_________________
Blog: kevin-fleischer.de und fbaingermany.com


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Aug 07, 2009 19:20 
Offline
DGL Member
Benutzeravatar

Registriert: Di Okt 03, 2006 14:07
Beiträge: 1277
Wohnort: Wien
Also, ich denk mal nicht, dass der im Wiki steht. Der Artikel, den ich damals geschrieben habe, hab ich vor ziemlich genau einem Jahr erzeugt (ich habe grade nachgesehen), und zwar aufgrund dieses Threads hier. Ganz unten habe ich bloss einen Hinweis dazugeschrieben, wie das Ganze prinzipiell geht.

Ich habe dafür getesteten Sourcode, den ich auch gerne fürs Wiki zur Verfügung stelle. Allerdings arbeite ich schon lange nicht mehr mit der VCL, es handelt sich um die Windows API. Umschreiben möchte ich das derzeit aber nicht: ich arbeite mich grade in ein anderes Gebiet ein.


Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  [ 24 Beiträge ]  Gehe zu Seite Vorherige  1, 2
Foren-Übersicht » Programmierung » Allgemein


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 9 Gäste


Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.

Suche nach:
Gehe zu:  
  Powered by phpBB® Forum Software © phpBB Group
Deutsche Übersetzung durch phpBB.de
[ Time : 0.010s | 15 Queries | GZIP : On ]