CentrED

(*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License, Version 1.0 only

 * (the "License").  You may not use this file except in compliance

 * with the License.

 *

 * You can obtain a copy of the license at

 * http://www.opensource.org/licenses/cddl1.php.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at

 * http://www.opensource.org/licenses/cddl1.php.  If applicable,

 * add the following below this CDDL HEADER, with the fields enclosed

 * by brackets "[]" replaced with your own identifying * information:

 *      Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 *

 *

 *      Portions Copyright 2007 Andreas Schneider

 *)

unit UOverlayUI;

{$mode objfpc}{$H+}

interface

uses

  Classes, SysUtils, Gl, GLU, ImagingTypes, ImagingClasses, ImagingOpenGL,

  OpenGLContext, ImagingUtility;

type

  { TGLArrow }

  TGLArrow = class(TObject)

    constructor Create(AGraphic: TSingleImage);

    destructor Destroy; override;

  protected

    FGraphic: TSingleImage;

    FTexture: GLuint;

    FRealWidth: Integer;

    FRealHeight: Integer;

    FWidth: Integer;

    FHeight: Integer;

    FCurrentX: Integer;

    FCurrentY: Integer;

    procedure UpdateTexture;

  public

    property Width: Integer read FWidth;

    property Height: Integer read FHeight;

    property CurrentX: Integer read FCurrentX;

    property CurrentY: Integer read FCurrentY;

    function HitTest(AX, AY: Integer): Boolean;

    procedure DrawGL(AX, AY: Integer; AActive: Boolean = False);

  end;

  { TOverlayUI }

  TOverlayUI = class(TObject)

    constructor Create;

    destructor Destroy; override;

  protected

    FArrows: array[0..7] of TGLArrow;

    FActiveArrow: Integer;

    FVisible: Boolean;

  public

    property ActiveArrow: Integer read FActiveArrow write FActiveArrow;

    property Visible: Boolean read FVisible write FVisible;

    function HitTest(AX, AY: Integer): Integer;

    procedure Draw(AContext: TOpenGLControl);

  end;

implementation

uses

  UResourceManager;

{ TGLArrow }

constructor TGLArrow.Create(AGraphic: TSingleImage);

var

  caps: TGLTextureCaps;

begin

  inherited Create;

  FRealWidth := AGraphic.Width;

  FRealHeight := AGraphic.Height;

  GetGLTextureCaps(caps);

  if caps.PowerOfTwo then

  begin

    if IsPow2(FRealWidth) then FWidth := FRealWidth else FWidth := NextPow2(FRealWidth);

    if IsPow2(FRealHeight) then FHeight := FRealHeight else FHeight := NextPow2(FRealHeight);

  end else

  begin

    FWidth := FRealHeight;

    FHeight := FRealHeight;

  end;

  FGraphic := TSingleImage.CreateFromParams(FWidth, FHeight, ifA8R8G8B8);

  AGraphic.CopyTo(0, 0, FRealWidth, FRealHeight, FGraphic, 0, 0);

  FTexture := 0;

end;

destructor TGLArrow.Destroy;

begin

  if FGraphic <> nil then FreeAndNil(FGraphic);

  if FTexture <> 0 then glDeleteTextures(1, @FTexture);

  inherited Destroy;

end;

procedure TGLArrow.UpdateTexture;

begin

  if (FGraphic <> nil) and (FRealWidth > 0) and (FRealWidth > 0) then

  begin

    FTexture := CreateGLTextureFromImage(FGraphic.ImageDataPointer^, 0, 0, False);

    glBindTexture(GL_TEXTURE_2D, FTexture);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);

    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);

  end;

end;

function TGLArrow.HitTest(AX, AY: Integer): Boolean;

begin

  if (AX > -1) and (AX < FRealWidth) and (AY > -1) and (AY < FRealHeight) then

  begin

    Result := (FGraphic <> nil) and (Cardinal(PIntegerArray(FGraphic.Bits)^[AY * FWidth + AX] and $FF000000) > 0);

  end else

    Result := False;

end;

procedure TGLArrow.DrawGL(AX, AY: Integer; AActive: Boolean = False);

begin

  FCurrentX := AX;

  FCurrentY := AY;

  if FTexture = 0 then UpdateTexture;

  if FTexture <> 0 then

  begin

    if AActive then

    begin

      glEnable(GL_COLOR_LOGIC_OP);

      glLogicOp(GL_COPY_INVERTED);

    end;

    glBindTexture(GL_TEXTURE_2D, FTexture);

    glBegin(GL_QUADS);

      glTexCoord2f(0, 0); glVertex2d(AX, AY);

      glTexCoord2f(1, 0); glVertex2d(AX + FWidth, AY);

      glTexCoord2f(1, 1); glVertex2d(AX + FWidth, AY + FHeight);

      glTexCoord2f(0, 1); glVertex2d(AX, AY + FHeight);

    glEnd;

    if AActive then

      glDisable(GL_COLOR_LOGIC_OP);

  end;

end;

{ TOverlayUI }

constructor TOverlayUI.Create;

var

  i: Integer;

  arrow: TSingleImage;

begin

  inherited Create;

  FActiveArrow := -1;

  FVisible := False;

  arrow := TSingleImage.CreateFromStream(ResourceManager.GetResource(0));

  for i := 0 to 3 do

  begin

    FArrows[2*i] := TGLArrow.Create(arrow);

    arrow.Rotate(-90);

  end;

  arrow.Free;

  arrow := TSingleImage.CreateFromStream(ResourceManager.GetResource(1));

  for i := 0 to 3 do

  begin

    FArrows[2*i+1] := TGLArrow.Create(arrow);

    arrow.Rotate(-90);

  end;

  arrow.Free;

end;

destructor TOverlayUI.Destroy;

var

  i: Integer;

begin

  for i := 0 to 7 do

    if FArrows[i] <> nil then FreeAndNil(FArrows[i]);

  inherited Destroy;

end;

function TOverlayUI.HitTest(AX, AY: Integer): Integer;

var

  i: Integer;

begin

  Result := -1;

  i := 0;

  while (i <= 7) and (Result = -1) do

  begin

    if FArrows[i].HitTest(AX - FArrows[i].CurrentX, AY - FArrows[i].CurrentY) then

      Result := i;

    Inc(i);

  end;

end;

procedure TOverlayUI.Draw(AContext: TOpenGLControl);

begin

  if FVisible then

  begin

    FArrows[0].DrawGL(10, 10, FActiveArrow = 0);

    FArrows[1].DrawGL(AContext.Width div 2 - FArrows[1].Width div 2, 10,

                      FActiveArrow = 1);

    FArrows[2].DrawGL(AContext.Width - 10 - FArrows[2].Width, 10,

                      FActiveArrow = 2);

    FArrows[3].DrawGL(AContext.Width - 10 - FArrows[3].Width,

                      AContext.Height div 2 - FArrows[3].Height div 2,

                      FActiveArrow = 3);

    FArrows[4].DrawGL(AContext.Width - 10 - FArrows[4].Width,

                      AContext.Height - 10 - FArrows[4].Height,

                      FActiveArrow = 4);

    FArrows[5].DrawGL(AContext.Width div 2 - FArrows[5].Width div 2,

                      AContext.Height - 10 - FArrows[5].Height,

                      FActiveArrow = 5);

    FArrows[6].DrawGL(10, AContext.Height - 10 - FArrows[6].Height,

                      FActiveArrow = 6);

    FArrows[7].DrawGL(10, AContext.Height div 2 - FArrows[7].Height div 2,

                      FActiveArrow = 7);

  end;

end;

end.