unit uDLFight;

interface

uses
  dglOpenGL, Windows, SysUtils, Classes, Graphics, Forms, Controls, textures, uLog;

const
  NearClipping = 0;
  FarClipping  = 128 + 1; // +1 um auch die Ebene 128 anzuzeigen
  SizeX = 1024;
  SizeY = 768;
const
  Sel_PlayerFlag1 = 1;
  Sel_PlayerFlag2 = 2;

type
  TIntializeData = record
    TableWidth, TableHeight : Integer; // Höhe und Breite in Feldanzahl

    FigursPerPlayer : Integer;
    DLLPathPlayer1, DLLPathPlayer2 : string;
  end;

  TWinEvent = procedure(Sender: TObject; WinnerID : Integer) of Object;

  TDLMatch = class(TObject)
  private
    DC                                : HDC;  //Handle auf Zeichenfläche
    RC                                : HGLRC;//Rendering Context
    OGLDisplay : TWinControl;

    function IntializeOGL(Parent : TWinControl):boolean;
    procedure SetupGL;
  public
    Framerate : Integer;

    OnEndMatch : TWinEvent;
    procedure DisplayMouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
    procedure IdleHandler(Sender: TObject; var Done: Boolean);
    procedure Render;
    function Selection(xs,ys : Integer) : integer;
    constructor Create(pDisplay : TWinControl; Data : TIntializeData);
    destructor  Destroy(); override;
  end;

implementation

{ TDLMatch }

function TDLMatch.Selection(xs,ys : Integer) : integer;
var
  Puffer       : array[0..256] of GLUInt;
  Viewport     : TGLVectori4;
  Treffer,i    : Integer;
  Z_Wert       : GLUInt;
  Getroffen    : GLUInt;
begin
  glGetIntegerv(GL_VIEWPORT, @viewport);      //Die Sicht speichern
  glSelectBuffer(256, @Puffer);               //Den Puffer zuordnen

  glMatrixMode(GL_PROJECTION);                //In den Projektionsmodus
  glRenderMode(GL_SELECT);                    //In den Selectionsmodus schalten
  glPushMatrix;                               //Um unsere Matrix zu sichern
  glLoadIdentity;                             //Und dieselbige wieder zurückzusetzen

  gluPickMatrix(xs, viewport[3]-ys, 1.0, 1.0, viewport);
  gluPerspective(60.0, Viewport[2]/Viewport[3], NearClipping, FarClipping);

  Render;                                     //Die Szene zeichnen
  glMatrixMode(GL_PROJECTION);                //Wieder in den Projektionsmodus
  glPopMatrix;                                //und unsere alte Matrix wiederherzustellen

  treffer := glRenderMode(GL_RENDER);         //Anzahl der Treffer auslesen

  Getroffen := High(GLUInt);                  //Höchsten möglichen Wert annehmen
  Z_Wert := High(GLUInt);                     //Höchsten Z - Wert
  for i := 0 to Treffer-1 do
    if Puffer[(i*4)+1] < Z_Wert then
    begin
      getroffen       := Puffer[(i*4)+3];
      Z_Wert := Puffer[(i*4)+1];
    end;

  if getroffen=High(GLUInt)
    then Result := -1
    else Result := getroffen;
end;

constructor TDLMatch.Create(pDisplay : TWinControl; Data : TIntializeData);
begin
  inherited create;

  OGLDisplay := pDisplay;
  if not IntializeOGL(pDisplay) then
    raise Exception.Create('OpenGL was not intialized correctly');

  SetupGL;
end;

destructor TDLMatch.destroy();
begin
  DeactivateRenderingContext;
  DestroyRenderingContext(RC);
  ReleaseDC(OGLDisplay.Handle, DC);

  inherited destroy;
end;

procedure TDLMatch.DisplayMouseDown(Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
var
  iSelection : Integer;
begin
  iSelection := Selection(X,Y);
  if (iSelection=Sel_PlayerFlag1)OR(iSelection=Sel_PlayerFlag2) then
  begin
    dl_Log('SELECTION');
  end;
  dl_Log(iSelection);
end;

procedure TDLMatch.IdleHandler(Sender: TObject; var Done: Boolean);
begin
  Render;
  sleep(1); // zur Prozessorschonung, ggf deaktivieren
  Done:= false;
end;

function TDLMatch.IntializeOGL(Parent : TWinControl):boolean;
begin
  DC:= GetDC(Parent.Handle);
  RC:= CreateRenderingContext( DC,
                               [opDoubleBuffered],
                               32,
                               24,
                               0,0,0,
                               0);
  ActivateRenderingContext(DC, RC);
end;

procedure TDLMatch.Render;
begin
  glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);

  glMatrixMode(GL_PROJECTION);
    glLoadIdentity;
    SetupGL;

  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity;

  glInitNames;
  glPushName(0);

  //----------------------------------------------------------------------------
  glLoadName(1);
  glBegin(GL_QUADS);
    glVertex3f(050,50,-128); // unten links
    glVertex3f(100,50,-128); // unten rechts
    glVertex3f(100,100,-128); // oben rechts
    glVertex3f(50,100,-128); // oben links
  glEnd;

  glRotatef(90,0,0,1);

  glLoadName(2);
  glBegin(GL_QUADS);
    glVertex3f(50,50,-128); // unten links
    glVertex3f(100,50,-128); // unten rechts
    glVertex3f(100,100,-128); // oben rechts
    glVertex3f(50,100,-128); // oben links
  glEnd;
  //----------------------------------------------------------------------------

  SwapBuffers(DC);
end;

procedure TDLMatch.SetupGL;
begin
  glOrtho(-(SizeX/2), SizeX/2, -(SizeY/2), SizeY/2, NearClipping, FarClipping);         // Aktiviert 2D Perspektive
  glViewport(0,0,OGLDisplay.ClientWidth,OGLDisplay.ClientHeight);
  glEnable(GL_DEPTH_TEST);                                        // Aktiviert Tiefentest
  glDepthFunc(GL_LESS);                                             // Depth Buffer Setup
end;

end.

  glOrtho(-(SizeX/2), SizeX/2, -(SizeY/2), SizeY/2, NearClipping, FarClipping);

function TDLMatch.Selection(xs,ys : Integer) : integer;
var
  Puffer       : array[0..256] of GLUInt;
  Viewport     : TGLVectori4;
  Treffer,i    : Integer;
  Z_Wert       : GLUInt;
  Getroffen    : GLUInt;
begin
  glGetIntegerv(GL_VIEWPORT, @viewport);      //Die Sicht speichern
  glSelectBuffer(256, @Puffer);               //Den Puffer zuordnen

  glMatrixMode(GL_PROJECTION);                //In den Projektionsmodus
  glRenderMode(GL_SELECT);                    //In den Selectionsmodus schalten
  glPushMatrix;                               //Um unsere Matrix zu sichern
  glLoadIdentity;                             //Und dieselbige wieder zurückzusetzen

  gluPickMatrix(xs, viewport[3]-ys, 1.0, 1.0, viewport);
  glOrtho(-(SizeX/2), SizeX/2, -(SizeY/2), SizeY/2, NearClipping, FarClipping);

  Render;                                     //Die Szene zeichnen
  glMatrixMode(GL_PROJECTION);                //Wieder in den Projektionsmodus
  glPopMatrix;                                //und unsere alte Matrix wiederherzustellen

  treffer := glRenderMode(GL_RENDER);         //Anzahl der Treffer auslesen

  Getroffen := High(GLUInt);                  //Höchsten möglichen Wert annehmen
  Z_Wert := High(GLUInt);                     //Höchsten Z - Wert
  for i := 0 to Treffer-1 do
    if Puffer[(i*4)+1] < Z_Wert then
    begin
      getroffen       := Puffer[(i*4)+3];
      Z_Wert := Puffer[(i*4)+1];
    end;

  if getroffen=High(GLUInt)
    then Result := -1
    else Result := getroffen;
end;