try
    DeactivateRenderingContext;
  except
  end;

  try
    PF := gluGetPixelFormat(Form.Handle, [opDoubleBuffered], 32, 24, 0, 0, 0, 0);
    RC := gluCreateRenderContext(Form.Handle, PF);
  except
    FreeAll;
    exit;
  end;

////////////////////////////////////////////////////////////////////////////////////////////////////
//gibt den ErrorCode des letzten Fehler zurück
//@result: ErrorCode des letzten Errors;
function gluGetLastError: Cardinal;
begin
  result := LastError;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////
//gibt einen aussagekräftigen String passend zum ErrorCode zurück
//@ErrorCode: ErrorCode, der in einen String umgewandelt werden soll;
//@result: String mit Beschreibung zum Error;
function gluGetErrorString(ErrorCode: Cardinal): String;
begin
  case ErrorCode of
    ERROR_INIT_OPENGL     : result := 'Initializing OpenGL failed!';
    ERROR_NO_PIXELFORMAT  : result := 'No Pixelformat!';
    ERROR_CREATE_DC       : result := 'Creating Device Context failed!';
    ERROR_SET_PIXELFORMAT : result := 'Setting Pixelformat failed!';
    ERROR_CREATE_RC       : result := 'Creating Render Context failed!';
    ERROR_ACTIVATE_RC     : result := 'Activating Render Contect failed!';
    ERROR_NO_DC           : result := 'No Device Context!';
    ERROR_NO_RC           : result := 'No Render Context!';
    ERROR_AA_NOT_SUPPORTED: result := 'AntiAliasing not supported!';
    else                    result := 'noError';
  end;
  result := 'glUtils: '+result;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////
//ermittelt alle Pixelformate, die MultiSampling unterstützen
//@PFList: Liste in die die Pixelformate geschieben werden;
//@SampleList: Liste in die die SampleRate passend zum Pixelformat geschrieben wird;
//@MaxCount: Maximale Länge der übergebenen Listen;
//@Count: Anzahl der gefundenen Pixelformate in der Liste;
function gluGetAntiAliasingPixelFormats(const PFList, SampleList: PglInt; const MaxCount: Integer; var Count: Integer): Boolean;
var
  //temporäres Fenster zum erzeugen des RC
  Form: TForm;
  //ARB_Erweiterung vorhanden
  //|          EXT_Erweiterung vorhanden
  MultiARBSup, MultiEXTSup: Boolean;
  //Liste der Integer Attribute
  IAtrib: array[0..18] of Integer;
  //Liste der Float Attribute (nur 0, da kein Wert)
  FAtrib: GLFloat;
  //temp. PixelFormat
  //| Schleifenvariable
  //| |  AttributName
  PF, i, QueryAtrib: Integer;
  //Zeiger auf zum hochzählen ni der Liste
  PPosiblePF, PSample: PglInt;
  //temp. RenderKontext
  //| RenderContext, der zurvor aktiviert war
  RC, OldRC: TgluRenderContext;
begin
  LastError := ERROR_NO_ERROR;
  result    := false;
  OldRC.DC  := wglGetCurrentDC;
  OldRC.RC  := wglGetCurrentContext;

  Form := TForm.Create(nil);
  PF := gluGetPixelFormat(Form.Handle, [opDoubleBuffered], 32, 24, 0, 0, 0, 0);
  RC := gluCreateRenderContext(Form.Handle, PF);
  if RC.RC = 0 then begin
    Form.Free;
    exit;
  end;
  if not gluActivateRenderContext(RC) then begin
    Form.Free;
    gluDestroyRenderContext(RC);
    exit;
  end;

  //Pixelformate mit AA auslesen
  MultiARBSup := false;
  MultiEXTSup := false;
  if WGL_ARB_extensions_string and
     WGL_ARB_pixel_format and
     (WGL_ARB_MULTISAMPLE or GL_ARB_MULTISAMPLE) then
    multiARBSup := true;
  if WGL_EXT_extensions_string and
     WGL_EXT_pixel_format and
     (WGL_EXT_MULTISAMPLE or GL_EXT_MULTISAMPLE) then
    multiEXTSup := true;

  if multiARBSup then
    Read_WGL_ARB_pixel_format
  else if multiEXTSup then   
    Read_WGL_EXT_pixel_format;

  if not (MultiARBSup or MultiEXTSup) then begin
    Form.Free;
    gluDestroyRenderContext(RC);
    LastError := ERROR_AA_NOT_SUPPORTED;
    exit;
  end;

  FAtrib     := 0;
  IAtrib[00] := WGL_DRAW_TO_WINDOW_ARB;
  IAtrib[01] := 1;
  IAtrib[02] := WGL_SUPPORT_OPENGL_ARB;
  IAtrib[03] := 1;
  IAtrib[04] := WGL_DOUBLE_BUFFER_ARB;
  IAtrib[05] := 1;
  IAtrib[06] := WGL_PIXEL_TYPE_ARB;
  IAtrib[07] := WGL_TYPE_RGBA_ARB;
  IAtrib[08] := WGL_COLOR_BITS_ARB;
  IAtrib[09] := 32;
  IAtrib[10] := WGL_ALPHA_BITS_ARB;
  IAtrib[11] := 0;
  IAtrib[12] := WGL_DEPTH_BITS_ARB;
  IAtrib[13] := 24;
  IAtrib[14] := WGL_STENCIL_BITS_ARB;
  IAtrib[15] := 0;
  IAtrib[16] := WGL_SAMPLE_BUFFERS_ARB;
  IAtrib[17] := 1;
  IAtrib[18] := 0;

  if multiARBSup then
    wglChoosePixelFormatARB(RC.DC, @IAtrib, @FAtrib, MaxCount, PFList, @Count)
  else if multiEXTSup then
    wglChoosePixelFormatEXT(RC.DC, @IAtrib, @FAtrib, MaxCount, PFList, @Count);

  if Count > MaxCount then
    Count := MaxCount;

  QueryAtrib := WGL_SAMPLES_ARB;
  PSample    := SampleList;
  PPosiblePF := PFList;
  for i := 0 to Count-1 do begin
    if multiARBSup then
      wglGetPixelFormatAttribivARB(RC.DC, PPosiblePF^, 0, 1, @QueryAtrib, PSample)
    else if multiEXTSup then
      wglGetPixelFormatAttribivEXT(RC.DC, PPosiblePF^, 0, 1, @QueryAtrib, PSample);
    inc(PSample);
    inc(PPosiblePF);
  end;

  Form.Free;
  gluDestroyRenderContext(RC);
  result := True;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////
//erstellt einen RenderContext mit dem übergebenen PixelFormat. Wenn das angegebene
//AntiAliasing Pixelformat nicht unterstützt wird der 0 ist, erfolgt automatisch
//ein FallBack auf das normale PixelFormat
//@Handle: Handle für das der RenderContext erzeugt werden soll;
//@PixelFormat: FallBack-PixelFormat falls AAPixelFormat 0 oder nicht gültig;
//@AAPixelFormat: Pixelformat mit aktiviertem AntiAliasing;
//@result: Device- und erzeugter RenderContext, für das übergebene Handle;
function gluCreateRenderContext(const Handle: HWND; const PixelFormat: Integer): TgluRenderContext;
begin
  LastError     := ERROR_NO_ERROR;
  result.DC     := 0;
  result.RC     := 0;
  result.Handle := 0;

  if GL_LibHandle = nil then
    if not InitOpenGL then begin
      LastError := ERROR_INIT_OPENGL;
      exit;
    end;

  if PixelFormat = 0 then begin
    LastError := ERROR_NO_PIXELFORMAT;
    exit;
  end;

  result.Handle := Handle;
  result.DC := GetDC(Handle);
  if result.DC = 0 then begin
    LastError := ERROR_CREATE_DC;
    exit;
  end;

  if not SetPixelFormat(result.DC, PixelFormat, nil) then begin
    ReleaseDC(result.Handle, result.DC);
    LastError := ERROR_SET_PIXELFORMAT;
    exit;
  end;

  result.RC := wglCreateContext(result.DC);
  if result.RC = 0 then begin
    ReleaseDC(result.Handle, result.DC);
    LastError := ERROR_CREATE_RC;
    exit;
  end;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////
//gibt den RenderContext frei
//@RC: RenderContext der freigegeben werden soll;
procedure gluDestroyRenderContext(const RC: TgluRenderContext);
var CurrentRC: HGLRC;
begin
  CurrentRC := wglGetCurrentDC;
  if CurrentRC <> 0 then
    DeactivateRenderingContext;
  if RC.RC <> 0 then
    DestroyRenderingContext(RC.RC);
  if RC.DC <> 0 then
    ReleaseDC(RC.Handle, RC.DC);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////
//Aktiviert einen RenderContext
//RC: RenderContext der aktiviert werden soll;
function gluActivateRenderContext(const RC: TgluRenderContext): Boolean;
begin
  result := false;
  LastError := ERROR_NO_ERROR;
  if RC.DC = 0 then begin
    LastError := ERROR_NO_DC;
    exit;
  end;
  if RC.RC = 0 then begin
    LastError := ERROR_NO_RC;
    exit;
  end;
  if not wglMakeCurrent(RC.DC, RC.RC) then begin
    LastError := ERROR_ACTIVATE_RC;
    exit;
  end;
  ReadImplementationProperties;
  ReadExtensions;
  result := true;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TForm1.CreateRenderContext;
var
  PF: Integer;
  PFList, SampleList: array[0..15] of Integer;
  i, Count: Integer;

  function GetMaxAAPF: Integer;
  var max, max_i, i: Integer;
  begin
    max_i := 0;
    max   := 0;
    for i := 0 to Count-1 do
      if max < SampleList[i] then begin
        max := SampleList[i];
        max_i := i;
      end;
    result := PFList[max_i];
  end;   

begin
  for i := 0 to 15 do begin
    PFList[i]     := 0;
    SampleList[i] := 0;
  end;
  Count := 0;

  if not gluGetAntiAliasingPixelFormats(@PFList[0], @SampleList[0], Length(PFList), Count) then begin
    MessageDLG('Can''t create RenderContext with AA enabled. ErrorMessage: "' +
       gluGetErrorString(gluGetLastError) + '". Try Fallback to normal RenderContext!', mtWarning, [mbOK], 0);
  end else begin
    PF := GetMaxAAPF;
    RC := gluCreateRenderContext(RenderPanel.Handle, PF);
    if RC.RC = 0 then begin
      MessageDLG('Can''t create RenderContext with AA enabled. ErrorMessage: "' +
        gluGetErrorString(gluGetLastError) + '". Try Fallback to normal RenderContext!', mtWarning, [mbOK], 0);
    end;
  end;

  if RC.RC = 0 then begin
    PF := gluGetPixelFormat(RenderPanel.Handle, [opDoubleBuffered], 32, 24, 0, 0, 0, 0);
    RC := gluCreateRenderContext(RenderPanel.Handle, PF);
    if RC.RC = 0 then begin
      MessageDLG('Can''t create RenderContext with normal PixelFormat. ErrorMessage: "' +
        gluGetErrorString(gluGetLastError) + '". Application terminated!', mtError, [mbOK], 0);
      Application.Terminate;
    end;
  end;
end;