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 2009 Andreas Schneider

 *)

unit ULightManager;

{$mode objfpc}{$H+}

interface

uses

  Classes, SysUtils, Imaging, ImagingTypes, ImagingClasses, ImagingCanvases,

  ImagingOpenGL, GL, GLu, GLext, fgl, ULandscape, UWorldItem, UCacheManager;

type

  TCalculateOffset = procedure(AX, AY: Integer; out DrawX, DrawY: Integer) of object;

  { TLightMaterial }

  TLightMaterial = class(TSimpleMaterial)

    constructor Create(AGraphic: TBaseImage);

    destructor Destroy; override;

  protected

    FCanvas: TFastARGB32Canvas;

  public

    property Canvas: TFastARGB32Canvas read FCanvas;

  end;

  TLightCache = specialize TCacheManager<TLightMaterial>;

  TLightManager = class;

  { TLightSource }

  TLightSource = class

    constructor Create(AManager: TLightManager; AWorldItem: TWorldItem);

    destructor Destroy; override;

  protected

    FX: Integer;

    FY: Integer;

    FZ: SmallInt;

    FMaterial: TLightMaterial;

  public

    property X: Integer read FX;

    property Y: Integer read FY;

    property Z: SmallInt read FZ;

    property Material: TLightMaterial read FMaterial;

  end;

  TLightSources = specialize TFPGObjectList<TLightSource>;

  { TLightManager }

  TLightManager = class

    constructor Create(ACalculateOffset: TCalculateOffset);

    destructor Destroy; override;

  protected

    FLightSources: TLightSources;

    FOverlay: TSingleImage;

    FOverlayTexture: GLuint;

    FLightLevel: Byte;

    FValid: Boolean;

    FCalculateOffset: TCalculateOffset;

    FLightCache: TLightCache;

    FUseFBO: Boolean;

    FInitialized: Boolean;

    function GetLight(AID: Integer): TLightMaterial;

    procedure SetLightLevel(AValue: Byte);

    procedure UpdateOverlay(AScreenRect: TRect);

  public

    property LightLevel: Byte read FLightLevel write SetLightLevel;

    procedure InitGL;

    procedure UpdateLightMap(ALeft, AWidth, ATop, AHeight: Integer;

      AScreenBuffer: TScreenBuffer);

    procedure Draw(AScreenRect: TRect);

  end;

implementation

uses

  UGameResources, UTiledata, UStatics, UMap, ULight, Logging;

{ TLightManager }

constructor TLightManager.Create(ACalculateOffset: TCalculateOffset);

begin

  FCalculateOffset := ACalculateOffset;

  FLightSources := TLightSources.Create(True);

  FLightLevel := 0;

  FLightCache := TLightCache.Create(32);

  FInitialized := False;

end;

destructor TLightManager.Destroy;

begin

  FreeAndNil(FLightSources);

  FreeAndNil(FOverlay);

  FreeAndNil(FLightCache);

  glDeleteTextures(1, @FOverlayTexture);

  inherited Destroy;

end;

function TLightManager.GetLight(AID: Integer): TLightMaterial;

var

  light: TLight;

begin

  Result := nil;

  if not FLightCache.QueryID(AID, Result) then

  begin

    if ResMan.Lights.Exists(AID) then

    begin

      light := ResMan.Lights.GetLight(AID);

      Result := TLightMaterial.Create(light.Graphic);

      FLightCache.StoreID(AID, Result);

      light.Free;

    end;

  end;

end;

procedure TLightManager.SetLightLevel(AValue: Byte);

begin

  FLightLevel := AValue;

  FValid := False;

end;

procedure TLightManager.UpdateOverlay(AScreenRect: TRect);

var

  canvas: TFastARGB32Canvas;

  color: TColor32Rec;

  i: Integer;

  lightMaterial: TLightMaterial;

  colorGL: GLclampf;

  fbo: GLuint;

begin

  glDeleteTextures(1, @FOverlayTexture);

  if FUseFBO then

  begin

    glGenTextures(1, @FOverlayTexture);

    glBindTexture(GL_TEXTURE_2D, FOverlayTexture);

    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, AScreenRect.Right,

      AScreenRect.Bottom, 0, GL_RGBA, GL_UNSIGNED_BYTE, nil);

    glBindTexture(GL_TEXTURE_2D, 0);

    glGenFramebuffersEXT(1, @fbo);

    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);

    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,

      GL_TEXTURE_2D, FOverlayTexture, 0);

    colorGL :=(32 - lightLevel) / 32;

    glClearColor(colorGL, colorGL, colorGL, 1);

    glClear(GL_COLOR_BUFFER_BIT);

    glBlendFunc(GL_ONE, GL_ONE);

    for i := 0 to FLightSources.Count - 1 do

      begin

        lightMaterial := FLightSources[i].Material;

        if lightMaterial <> nil then

        begin

          glBindTexture(GL_TEXTURE_2D, lightMaterial.Texture);

          glBegin(GL_QUADS);

            glTexCoord2i(0, 0);

            glVertex2i(FLightSources[i].FX - lightMaterial.RealWidth div 2,

              FLightSources[i].FY - lightMaterial.RealHeight div 2);

            glTexCoord2i(0, 1);

            glVertex2i(FLightSources[i].FX - lightMaterial.RealWidth div 2,

              FLightSources[i].FY - lightMaterial.RealHeight div 2 +

              lightMaterial.Height);

            glTexCoord2i(1, 1);

            glVertex2i(FLightSources[i].FX - lightMaterial.RealWidth div 2 +

              lightMaterial.Width, FLightSources[i].FY -

              lightMaterial.RealHeight div 2 + lightMaterial.Height);

            glTexCoord2i(1, 0);

            glVertex2i(FLightSources[i].FX - lightMaterial.RealWidth div 2 +

              lightMaterial.Width,

              FLightSources[i].FY - lightMaterial.RealHeight div 2);

          glEnd;

        end;

      end;

    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);

    glDeleteFramebuffersEXT(1, @fbo);

  end else

  begin

    FOverlay.Free;

    color.A := $FF;

    color.R := ((32 - FLightLevel) * 255) div 32;

    color.G := color.R;

    color.B := color.R;

    FOverlay := TSingleImage.CreateFromParams(AScreenRect.Right,

      AScreenRect.Bottom, ifA8R8G8B8);

    canvas := TFastARGB32Canvas.CreateForImage(FOverlay);

    try

      canvas.FillColor32 := color.Color;

      canvas.FillRect(AScreenRect);

      for i := 0 to FLightSources.Count - 1 do

      begin

        lightMaterial := FLightSources[i].Material;

        if lightMaterial <> nil then

        begin

          lightMaterial.Canvas.DrawAdd(lightMaterial.Canvas.ClipRect, canvas,

            FLightSources[i].FX - lightMaterial.RealWidth div 2,

            FLightSources[i].FY - lightMaterial.RealHeight div 2);

        end;

      end;

    finally

      canvas.Free;

    end;

    FOverlayTexture := CreateGLTextureFromImage(FOverlay.ImageDataPointer^);

  end;

  FValid := True;

end;

procedure TLightManager.InitGL;

begin

  FUseFBO := Load_GL_EXT_framebuffer_object;

end;

procedure TLightManager.UpdateLightMap(ALeft, AWidth, ATop, AHeight: Integer;

  AScreenBuffer: TScreenBuffer);

var

  blockInfo: PBlockInfo;

  lights: TWorldItemList;

  i, x, y, tileID: Integer;

  tileData: TTiledata;

  tileMap: array of array of TWorldItem;

begin

  //Logger.EnterMethod([lcClient, lcDebug], 'UpdateLightMap');

  FLightSources.Clear;

  {Logger.Send([lcClient, lcDebug], 'AWidth', AWidth);

  Logger.Send([lcClient, lcDebug], 'AHeight', AHeight);}

  lights := TWorldItemList.Create(False);

  SetLength(tileMap, AWidth, AHeight);

  for x := 0 to AWidth - 1 do

    for y := 0 to AHeight - 1 do

      tileMap[x,y] := nil;

  blockInfo := nil;

  while AScreenBuffer.Iterate(blockInfo) do

  begin

    if blockInfo^.State = ssNormal then

    begin

      if blockInfo^.Item is TStaticItem then

        tileID := blockInfo^.Item.TileID + $4000

      else

        tileID := blockInfo^.Item.TileID;

      tileData := ResMan.Tiledata.TileData[tileID];

      if tdfLightSource in tileData.Flags then

        lights.Add(blockInfo^.Item)

      else

        tileMap[blockInfo^.Item.X - ALeft, blockInfo^.Item.Y - ATop] :=

          blockInfo^.Item;

    end;

  end;

  for i := 0 to lights.Count - 1 do

  begin

    x := lights[i].X + 1 - ALeft;

    y := lights[i].Y + 1 - ATop;

    if (x = AWidth) or (y = AHeight) or (tileMap[x,y] = nil) or

      (tileMap[x,y].Z < lights[i].Z + 5) then

      FLightSources.Add(TLightSource.Create(Self, lights[i]));

  end;

  lights.Free;

  FValid := False;

  //Logger.ExitMethod([lcClient, lcDebug], 'UpdateLightMap');

end;

procedure TLightManager.Draw(AScreenRect: TRect);

begin

  if not FInitialized then

    InitGL;

  glColor4f(1, 1, 1, 1);

  if not FValid then

    UpdateOverlay(AScreenRect);

  glBindTexture(GL_TEXTURE_2D, FOverlayTexture);

  glBlendFunc(GL_ZERO, GL_SRC_COLOR);

  glBegin(GL_QUADS);

  if FUseFBO then

  begin

    glTexCoord2i(0, 1);

    glVertex2i(AScreenRect.Left, AScreenRect.Top);

    glTexCoord2i(0, 0);

    glVertex2i(AScreenRect.Left, AScreenRect.Bottom);

    glTexCoord2i(1, 0);

    glVertex2i(AScreenRect.Right, AScreenRect.Bottom);

    glTexCoord2i(1, 1);

    glVertex2i(AScreenRect.Right, AScreenRect.Top);

  end else

  begin

    glTexCoord2i(0, 0);

    glVertex2i(AScreenRect.Left, AScreenRect.Top);

    glTexCoord2i(0, 1);

    glVertex2i(AScreenRect.Left, AScreenRect.Bottom);

    glTexCoord2i(1, 1);

    glVertex2i(AScreenRect.Right, AScreenRect.Bottom);

    glTexCoord2i(1, 0);

    glVertex2i(AScreenRect.Right, AScreenRect.Top);

  end;

  glEnd;

end;

{ TLightSource }

constructor TLightSource.Create(AManager: TLightManager; AWorldItem: TWorldItem);

var

  lightID: Byte;

begin

  lightID := ResMan.Tiledata.StaticTiles[AWorldItem.TileID].Quality;

  FMaterial := AManager.GetLight(lightID);

  if FMaterial <> nil then

  begin

    AManager.FCalculateOffset(AWorldItem.X, AWorldItem.Y, FX, FY);

    FZ := AWorldItem.Z * 4;

    FY := FY + 22 - FZ;

    FMaterial.AddRef;

  end;

end;

destructor TLightSource.Destroy;

begin

  if FMaterial <> nil then

    FMaterial.DelRef;

  inherited Destroy;

end;

{ TLightMaterial }

constructor TLightMaterial.Create(AGraphic: TBaseImage);

begin

  inherited Create(AGraphic);

  FCanvas := TFastARGB32Canvas.CreateForImage(FGraphic);

end;

destructor TLightMaterial.Destroy;

begin

  FreeAndNil(FCanvas);

  inherited Destroy;

end;

end.