//Kapselt die Daten für einen RenderContext
TgluRenderContext = packed record
  DC: HDC;
  RC: HGLRC;
  Handle: HWND;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//ermittelt die SampleRate des MultiSampling eines PixelFormats
//@PixelFormat: PixelFormat, dessen SampleRate ermittelt werden soll;
//@result: SampleRate des PixelFormats (wenn 0 wird kein MultiSampling unterstüzt);
function gluGetSampleRate(const PixelFormat: Integer): Integer;
var
  Form: TForm;
  QueryAtrib, ResultAtrib, PF: Integer;
  multiARBSup, multiEXTSup: Boolean;
  RC: TgluRenderContext;
  procedure FreeAll;
  begin
    gluFreeRenderContext(RC);
    Form.Free;
  end;
begin
  result := 0;
  Form := TForm.Create(nil);
  try
    PF := gluGetPixelFormat(Form.Handle, [opDoubleBuffered], 32, 24, 0, 0, 0, 0);
    RC := gluCreateRenderContext(Form.Handle, PF);
  except
    FreeAll;
    exit;
  end;

  if not wglMakeCurrent(RC.DC, RC.RC) then begin
    FreeAll;
    exit;
  end;
  ReadImplementationProperties;
  ReadExtensions;

  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 not (multiARBSup or multiEXTSup) then begin
    FreeAll;
    exit;
  end;
  if multiARBSup then
    Read_WGL_ARB_pixel_format
  else if multiEXTSup then
    Read_WGL_EXT_pixel_format;
  QueryAtrib := WGL_SAMPLES_ARB;
  ResultAtrib := 0;
  if multiARBSup then
    wglGetPixelFormatAttribivARB(RC.DC, PixelFormat, 0, 1, @QueryAtrib, @ResultAtrib)
  else if multiARBSup then
    wglGetPixelFormatAttribivEXT(RC.DC, PixelFormat, 0, 1, @QueryAtrib, @ResultAtrib);
  result := ResultAtrib;

  FreeAll;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//ermittelt ein passendes Pixelformat
//@Handle: Handle des Objekts, dür das das Pixelformat bestimmt werden soll;
//@Options: opDoubleBuffered, opGDI oder opStereo;
//@ColorBits: Anzahl der Bits zu Darstellung der Farbe;
//@DepthBits: Anzahl der Bits für den TiefenBuffer;
//@StencilBits: Anzahl der Bits für den StencilBuffer;
//@AccumBits: Anzahl der Bits für den AccumBuffer;
//@AuxBuffers: Anzahl der Bits für den AuxBuffer;
function gluGetPixelFormat(const Handle: HWND; const Options: TRCOptions; const ColorBits, DepthBits,
  StencilBits, AccumBits, AuxBuffers, Layer: Integer): Integer;
const
  MemoryDCs = [OBJ_MEMDC, OBJ_METADC, OBJ_ENHMETADC];
var
  //DeviceContext
  DC: HDC;
  //Objekttyp des DCs
  AType: DWord;
  //Beschreibung zum passenden Pixelformat
  PFDescriptor: TPixelFormatDescriptor;
begin
  DC := GetDC(Handle);
  if DC = 0 then
    raise Exception.Create('gluGetPixelFormat: Getting Device Context failed!');
  with PFDescriptor do begin
    nSize    := SizeOf(PFDescriptor);
    nVersion := 1;
    dwFlags  := PFD_SUPPORT_OPENGL;
    AType    := GetObjectType(DC);
    if AType = 0 then
      raise Exception.Create('gluGetPixelFormat: Getting Object Type failed!');
    if opDoubleBuffered in Options   then dwFlags := dwFlags or PFD_DOUBLEBUFFER;
    if opGDI            in Options   then dwFlags := dwFlags or PFD_SUPPORT_GDI;
    if opStereo         in Options   then dwFlags := dwFlags or PFD_STEREO;
    if AType            in MemoryDCs then dwFlags := dwFlags or PFD_DRAW_TO_BITMAP
                                     else dwFlags := dwFlags or PFD_DRAW_TO_WINDOW;
                                     
    iPixelType   := PFD_TYPE_RGBA;
    cColorBits   := ColorBits;
    cDepthBits   := DepthBits;
    cStencilBits := StencilBits;
    cAccumBits   := AccumBits;
    cAuxBuffers  := AuxBuffers;

    if Layer = 0 then      iLayerType := PFD_MAIN_PLANE
    else if Layer > 0 then iLayerType := PFD_OVERLAY_PLANE
                      else iLayerType := Byte(PFD_UNDERLAY_PLANE);
  end;
  result := ChoosePixelFormat(DC, @PFDescriptor);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//ermittelt alle möglichen PixelForamte, die AntiAliasing unterstützen und fügt sie zur Liste hinzu
//@List: Liste in die die Samplerates geschrieben werden;
procedure gluGetAntiAliasingPixelFormats(const List: Pointer; const MaxCount: Integer);
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
  //| Nummer der ausgelesenen PixelFormate mit AntiAliasing
  PF, numPFs: Integer;
  //temp. RenderKontext
  RC: TgluRenderContext;

  //gibt die benutzen Variablen/Objekte frei
  procedure FreeAll;
  begin
    gluFreeRenderContext(RC);
    Form.Free;
  end;
begin
  //temp. Fenster und RenderContext erstellen
  Form := TForm.Create(nil);
  try
    PF := gluGetPixelFormat(Form.Handle, [opDoubleBuffered], 32, 24, 0, 0, 0, 0);
    RC := gluCreateRenderContext(Form.Handle, PF);
  except
    FreeAll;
    raise Exception.Create('gluAntiAliasingPixelFormats: Create Rendering Context failed!');
  end;
  if not wglMakeCurrent(RC.DC, RC.RC) then begin
    FreeAll;
    raise Exception.Create('gluAntiAliasingPixelFormats: Activating Rendering Context failed!');
  end;
  ReadImplementationProperties;
  ReadExtensions;

  //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;

  FAtrib := 0;
  if not (MultiARBSup or MultiEXTSup) then begin
    FreeAll;
    raise Exception.Create('gluAntiAliasingPixelFormats: AntiAliasing is not supported!');
  end;

  IAtrib[0] := WGL_DRAW_TO_WINDOW_ARB;
  IAtrib[1] := 1;
  IAtrib[2] := WGL_SUPPORT_OPENGL_ARB;
  IAtrib[3] := 1;
  IAtrib[4] := WGL_DOUBLE_BUFFER_ARB;
  IAtrib[5] := 1;
  IAtrib[6] := WGL_PIXEL_TYPE_ARB;
  IAtrib[7] := WGL_TYPE_RGBA_ARB;
  IAtrib[8] := WGL_COLOR_BITS_ARB;
  IAtrib[9] := 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, List, @numPFs)
  else if multiEXTSup then
    wglChoosePixelFormatEXT(RC.DC, @IAtrib, @FAtrib,
      MaxCount, List, @numPFs);
  if numPFs = 0 then begin
    FreeAll;
    raise Exception.Create('gluAntiAliasingPixelFormats: No PixelFormat Found!');
  end;

  FreeAll;
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
  result.DC     := 0;
  result.RC     := 0;
  result.Handle := 0;

  if GL_LibHandle = nil then
    if not InitOpenGL then
      raise Exception.Create('gluCreateRenderContext: Initializing OpenGL failed!');

  if PixelFormat = 0 then
    raise Exception.Create('gluCreateRenderContext: Unknown Pixelformat (' + IntToStr(PixelFormat) + ')');

  result.Handle := Handle;
  result.DC := GetDC(Handle);
  if result.DC = 0 then
    raise Exception.Create('gluCreateRenderContext: Getting Device Context failed!');
  if not SetPixelFormat(result.DC, PixelFormat, nil) then begin
    ReleaseDC(result.Handle, result.DC);
    raise Exception.Create('gluCreateRenderContext: Setting Pixelformat failed!');
  end;

  result.RC := wglCreateContext(result.DC);
  if result.RC = 0 then begin
    ReleaseDC(result.Handle, result.DC);
    raise Exception.Create('gluCreateRenderContext: Creating Rendering Context faild!');
  end;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//gibt den RenderContext frei
//@RC: RenderContext der freigegeben werden soll;
procedure gluFreeRenderContext(RC: TgluRenderContext);
begin
  try
    DeactivateRenderingContext;
  except
  end;
  if RC.RC <> 0 then
    DestroyRenderingContext(RC.RC);
  if RC.DC <> 0 then
    ReleaseDC(RC.Handle, RC.DC);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TForm1.CreateRenderContext;
var
  PF: Integer;
  AAList: array[0..15] of Integer;

  function GetAAPixelFormat(const SampleRate: Byte): Integer;
  var i: Integer;
  begin
    result := 0;
    for i := 0 to 15 do begin
      if SampleRate = gluGetSampleRate(AAList[i]) then begin
        result := AAList[i];
        exit;
      end;
    end;
  end;
 
begin
  try
    gluGetAntiAliasingPixelFormats(@AAList[0], Length(AAList));
    PF := GetAAPixelFormat(16);
    RC := gluCreateRenderContext(Form1.Handle, PF);
  except
    try
      PF := gluGetPixelFormat(Form1.Handle, [opDoubleBuffered], 32, 24, 0, 0, 0, 0);
      RC := gluCreateRenderContext(Form1.Handle, PF);
    except
      Application.Terminate;
    end;
  end;
end;