(*

 * Hedgewars, a worms-like game

 * Copyright (c) 2004-2008 Andrey Korotaev <unC0Rr@gmail.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; version 2 of the License

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA

 *)

unit uStore;

interface

uses uConsts, uTeams, SDLh, uFloat, GL;

{$INCLUDE options.inc}

procedure StoreInit;

procedure StoreLoad;

procedure StoreRelease;

procedure DrawSpriteFromRect(Sprite: TSprite; r: TSDL_Rect; X, Y, Height, Position: LongInt);

procedure DrawSprite (Sprite: TSprite; X, Y, Frame: LongInt);

procedure DrawSprite2(Sprite: TSprite; X, Y, FrameX, FrameY: LongInt);

procedure DrawSurfSprite(X, Y, Height, Frame: LongInt; Source: PTexture);

procedure DrawLand (X, Y: LongInt);

procedure DrawTexture(X, Y: LongInt; Texture: PTexture);

procedure DrawRotated(Sprite: TSprite; X, Y, Dir: LongInt; Angle: real);

procedure DrawRotatedF(Sprite: TSprite; X, Y, Frame, Dir: LongInt; Angle: real);

procedure DrawRotatedTex(Tex: PTexture; hw, hh, X, Y, Dir: LongInt; Angle: real);

procedure DrawCentered(X, Top: LongInt; Source: PTexture);

procedure DrawFromRect(X, Y: LongInt; r: PSDL_Rect; SourceTexture: PTexture);

procedure DrawHedgehog(X, Y: LongInt; Dir: LongInt; Pos, Step: LongWord; Angle: real);

function  RenderStringTex(s: string; Color: Longword; font: THWFont): PTexture;

procedure RenderHealth(var Hedgehog: THedgehog);

procedure AddProgress;

procedure FinishProgress;

function  LoadImage(const filename: string; hasAlpha, critical, setTransparent: boolean): PSDL_Surface;

procedure SetupOpenGL;

var PixelFormat: PSDL_PixelFormat;

 SDLPrimSurface: PSDL_Surface;

   PauseTexture: PTexture;

implementation

uses uMisc, uConsole, uLand, uLocale, GLU;

var

    HHTexture: PTexture;

procedure StoreInit;

begin

end;

procedure DrawRoundRect(rect: PSDL_Rect; BorderColor, FillColor: Longword; Surface: PSDL_Surface; Clear: boolean);

var r: TSDL_Rect;

begin

r:= rect^;

if Clear then SDL_FillRect(Surface, @r, 0);

BorderColor:= SDL_MapRGB(Surface^.format, BorderColor shr 16, BorderColor shr 8, BorderColor and $FF);

FillColor:= SDL_MapRGB(Surface^.format, FillColor shr 16, FillColor shr 8, FillColor and $FF);

r.y:= rect^.y + 1;

r.h:= rect^.h - 2;

SDL_FillRect(Surface, @r, BorderColor);

r.x:= rect^.x + 1;

r.w:= rect^.w - 2;

r.y:= rect^.y;

r.h:= rect^.h;

SDL_FillRect(Surface, @r, BorderColor);

r.x:= rect^.x + 2;

r.y:= rect^.y + 1;

r.w:= rect^.w - 4;

r.h:= rect^.h - 2;

SDL_FillRect(Surface, @r, FillColor);

r.x:= rect^.x + 1;

r.y:= rect^.y + 2;

r.w:= rect^.w - 2;

r.h:= rect^.h - 4;

SDL_FillRect(Surface, @r, FillColor)

end;

function WriteInRoundRect(Surface: PSDL_Surface; X, Y: LongInt; Color: LongWord; Font: THWFont; s: string): TSDL_Rect;

var w, h: LongInt;

    tmpsurf: PSDL_Surface;

    clr: TSDL_Color;

    Result: TSDL_Rect;

begin

TTF_SizeUTF8(Fontz[Font].Handle, Str2PChar(s), w, h);

Result.x:= X;

Result.y:= Y;

Result.w:= w + FontBorder * 2 + 4;

Result.h:= h + FontBorder * 2;

DrawRoundRect(@Result, cWhiteColor, cColorNearBlack, Surface, true);

clr.r:= Color shr 16;

clr.g:= (Color shr 8) and $FF;

clr.b:= Color and $FF;

tmpsurf:= TTF_RenderUTF8_Blended(Fontz[Font].Handle, Str2PChar(s), clr.value);

Result.x:= X + FontBorder + 2;

Result.y:= Y + FontBorder;

SDLTry(tmpsurf <> nil, true);

SDL_UpperBlit(tmpsurf, nil, Surface, @Result);

SDL_FreeSurface(tmpsurf);

Result.x:= X;

Result.y:= Y;

Result.w:= w + FontBorder * 2 + 4;

Result.h:= h + FontBorder * 2;

WriteInRoundRect:= Result

end;

procedure StoreLoad;

var s: string;

    procedure WriteNames(Font: THWFont);

    var t: LongInt;

        i: LongInt;

        r, rr: TSDL_Rect;

        drY: LongInt;

        texsurf: PSDL_Surface;

    begin

    r.x:= 0;

    r.y:= 0;

    drY:= cScreenHeight - 4;

    for t:= 0 to Pred(TeamsCount) do

     with TeamsArray[t]^ do

      begin

      NameTagTex:= RenderStringTex(TeamName, Clan^.Color, Font);

      r.w:= cTeamHealthWidth + 5;

      r.h:= NameTagTex^.h;

      texsurf:= SDL_CreateRGBSurface(SDL_SWSURFACE, r.w, r.h, 32, RMask, GMask, BMask, AMask);

      TryDo(texsurf <> nil, errmsgCreateSurface, true);

      TryDo(SDL_SetColorKey(texsurf, SDL_SRCCOLORKEY, 0) = 0, errmsgTransparentSet, true);

      DrawRoundRect(@r, cWhiteColor, cColorNearBlack, texsurf, true);

      rr:= r;

      inc(rr.x, 2); dec(rr.w, 4); inc(rr.y, 2); dec(rr.h, 4);

      DrawRoundRect(@rr, Clan^.Color, Clan^.Color, texsurf, false);

      HealthTex:= Surface2Tex(texsurf);

      SDL_FreeSurface(texsurf);

      dec(drY, r.h + 2);

      DrawHealthY:= drY;

      for i:= 0 to 7 do

          with Hedgehogs[i] do

               if Gear <> nil then

                  NameTagTex:= RenderStringTex(Name, Clan^.Color, fnt16);

      end;

    end;

    procedure MakeCrossHairs;

    var t: LongInt;

        tmpsurf, texsurf: PSDL_Surface;

        Color, i: Longword;

    begin

    s:= Pathz[ptGraphics] + '/' + cCHFileName;

    tmpsurf:= LoadImage(s, true, true, false);

    for t:= 0 to Pred(TeamsCount) do

      with TeamsArray[t]^ do

      begin

      texsurf:= SDL_CreateRGBSurface(SDL_SWSURFACE, tmpsurf^.w, tmpsurf^.h, 32, RMask, GMask, BMask, AMask);

      TryDo(texsurf <> nil, errmsgCreateSurface, true);

      Color:= Clan^.Color;

      Color:= SDL_MapRGB(texsurf^.format, Color shr 16, Color shr 8, Color and $FF);

      SDL_FillRect(texsurf, nil, Color);

      SDL_UpperBlit(tmpsurf, nil, texsurf, nil);

      TryDo(tmpsurf^.format^.BytesPerPixel = 4, 'Ooops', true);

      if SDL_MustLock(texsurf) then

         SDLTry(SDL_LockSurface(texsurf) >= 0, true);

      // make black pixel be alpha-transparent

      for i:= 0 to texsurf^.w * texsurf^.h - 1 do

          if PLongwordArray(texsurf^.pixels)^[i] = $FF000000 then PLongwordArray(texsurf^.pixels)^[i]:= 0;

      if SDL_MustLock(texsurf) then

         SDL_UnlockSurface(texsurf);

      CrosshairTex:= Surface2Tex(texsurf);

      SDL_FreeSurface(texsurf)

      end;

    SDL_FreeSurface(tmpsurf)

    end;

    procedure InitHealth;

    var i, t: LongInt;

    begin

    for t:= 0 to Pred(TeamsCount) do

     if TeamsArray[t] <> nil then

      with TeamsArray[t]^ do

          begin

          for i:= 0 to cMaxHHIndex do

              if Hedgehogs[i].Gear <> nil then

                 RenderHealth(Hedgehogs[i]);

          end

    end;

    procedure LoadGraves;

    var t: LongInt;

        texsurf: PSDL_Surface;

    begin

    for t:= 0 to Pred(TeamsCount) do

     if TeamsArray[t] <> nil then

      with TeamsArray[t]^ do

          begin

          if GraveName = '' then GraveName:= 'Simple';

          texsurf:= LoadImage(Pathz[ptGraves] + '/' + GraveName, false, true, true);

          GraveTex:= Surface2Tex(texsurf);

          SDL_FreeSurface(texsurf)

          end

    end;

    procedure GetExplosionBorderColor;

    var f: textfile;

        c1, c2: TSDL_Color;

    begin

    s:= Pathz[ptCurrTheme] + '/' + cThemeCFGFilename;

    WriteToConsole(msgLoading + s + ' ');

    Assign(f, s);

    {$I-}

    Reset(f);

    Readln(f, c1.r, c1.g, c1. b);

    Readln(f, c2.r, c2.g, c2. b);

    Close(f);

    {$I+}

    TryDo(IOResult = 0, msgFailed, true);

    WriteLnToConsole(msgOK);

    glClearColor(c1.r / 255, c1.g / 255, c1.b / 255, 0.99); // sky color

    cExplosionBorderColor:= c2.value or

                            $FF000000

    end;

var ii: TSprite;

    fi: THWFont;

    ai: TAmmoType;

    tmpsurf: PSDL_Surface;

    i: LongInt;

begin

for fi:= Low(THWFont) to High(THWFont) do

    with Fontz[fi] do

         begin

         s:= Pathz[ptFonts] + '/' + Name;

         WriteToConsole(msgLoading + s + '... ');

         Handle:= TTF_OpenFont(Str2PChar(s), Height);

         SDLTry(Handle <> nil, true);

         TTF_SetFontStyle(Handle, style);

         WriteLnToConsole(msgOK)

         end;

AddProgress;

GetExplosionBorderColor;

AddProgress;

WriteNames(fnt16);

MakeCrossHairs;

LoadGraves;

AddProgress;

for ii:= Low(TSprite) to High(TSprite) do

    with SpritesData[ii] do

         begin

         if AltPath = ptNone then

            tmpsurf:= LoadImage(Pathz[Path] + '/' + FileName, true, true, true)

         else begin

            tmpsurf:= LoadImage(Pathz[Path] + '/' + FileName, true, false, true);

            if tmpsurf = nil then

               tmpsurf:= LoadImage(Pathz[AltPath] + '/' + FileName, true, true, true)

            end;

         if Width = 0 then Width:= tmpsurf^.w;

         if Height = 0 then Height:= tmpsurf^.h;

         Texture:= Surface2Tex(tmpsurf);

         if saveSurf then Surface:= tmpsurf else SDL_FreeSurface(tmpsurf)

         end;

AddProgress;

tmpsurf:= LoadImage(Pathz[ptGraphics] + '/' + cHHFileName, true, true, true);

HHTexture:= Surface2Tex(tmpsurf);

SDL_FreeSurface(tmpsurf);

InitHealth;

PauseTexture:= RenderStringTex(trmsg[sidPaused], $FFFF00, fntBig);

for ai:= Low(TAmmoType) to High(TAmmoType) do

	with Ammoz[ai] do

		begin

		tmpsurf:= TTF_RenderUTF8_Blended(Fontz[fnt16].Handle, Str2PChar(trAmmo[NameId]), $FFFFFF);

		NameTex:= Surface2Tex(tmpsurf);

		SDL_FreeSurface(tmpsurf)

		end;

for i:= Low(CountTexz) to High(CountTexz) do

	begin

	tmpsurf:= TTF_RenderUTF8_Blended(Fontz[fnt16].Handle, Str2PChar(IntToStr(i) + 'x'), $FFFFFF);

	CountTexz[i]:= Surface2Tex(tmpsurf);

	SDL_FreeSurface(tmpsurf)

	end;

{$IFDEF DUMP}

SDL_SaveBMP_RW(LandSurface, SDL_RWFromFile('LandSurface.bmp', 'wb'), 1);

SDL_SaveBMP_RW(StoreSurface, SDL_RWFromFile('StoreSurface.bmp', 'wb'), 1);

{$ENDIF}

end;

procedure DrawFromRect(X, Y: LongInt; r: PSDL_Rect; SourceTexture: PTexture);

var rr: TSDL_Rect;

    _l, _r, _t, _b: real;

begin

if SourceTexture^.h = 0 then exit;

rr.x:= X;

rr.y:= Y;

rr.w:= r^.w;

rr.h:= r^.h;

_l:= r^.x / SourceTexture^.w;

_r:= (r^.x + r^.w) / SourceTexture^.w;

_t:= r^.y / SourceTexture^.h;

_b:= (r^.y + r^.h) / SourceTexture^.h;

glBindTexture(GL_TEXTURE_2D, SourceTexture^.id);

glBegin(GL_QUADS);

glTexCoord2f(_l, _t);

glVertex2i(X, Y);

glTexCoord2f(_r, _t);

glVertex2i(rr.w + X, Y);

glTexCoord2f(_r, _b);

glVertex2i(rr.w + X, rr.h + Y);

glTexCoord2f(_l, _b);

glVertex2i(X, rr.h + Y);

glEnd()

end;

procedure DrawTexture(X, Y: LongInt; Texture: PTexture);

begin

glBindTexture(GL_TEXTURE_2D, Texture^.id);

glBegin(GL_QUADS);

glTexCoord2f(0, 0);

glVertex2i(X, Y);

glTexCoord2f(1, 0);

glVertex2i(Texture^.w + X, Y);

glTexCoord2f(1, 1);

glVertex2i(Texture^.w + X, Texture^.h + Y);

glTexCoord2f(0, 1);

glVertex2i(X, Texture^.h + Y);

glEnd()

end;

procedure DrawRotated(Sprite: TSprite; X, Y, Dir: LongInt; Angle: real);

begin

DrawRotatedTex(SpritesData[Sprite].Texture,

		SpritesData[Sprite].Width,

		SpritesData[Sprite].Height,

		X, Y, Dir, Angle)

end;

procedure DrawRotatedF(Sprite: TSprite; X, Y, Frame, Dir: LongInt; Angle: real);

begin

glPushMatrix;

glTranslatef(X, Y, 0);

glRotatef(Angle, 0, 0, 1);

if Dir < 0 then glScalef(-1.0, 1.0, 1.0);

DrawSprite(Sprite, -SpritesData[Sprite].Width div 2, -SpritesData[Sprite].Height div 2, Frame);

glPopMatrix

end;

procedure DrawRotatedTex(Tex: PTexture; hw, hh, X, Y, Dir: LongInt; Angle: real);

begin

glPushMatrix;

glTranslatef(X, Y, 0);

if Dir < 0 then

   begin

   hw:= - hw;

   glRotatef(Angle, 0, 0, -1);

   end else

   glRotatef(Angle, 0, 0,  1);

glBindTexture(GL_TEXTURE_2D, Tex^.id);

glBegin(GL_QUADS);

glTexCoord2f(0, 0);

glVertex2i(-hw, -hh);

glTexCoord2f(1, 0);

glVertex2i(hw, -hh);

glTexCoord2f(1, 1);

glVertex2i(hw, hh);

glTexCoord2f(0, 1);

glVertex2i(-hw, hh);

glEnd();

glPopMatrix

end;

procedure DrawSpriteFromRect(Sprite: TSprite; r: TSDL_Rect; X, Y, Height, Position: LongInt);

begin

r.y:= r.y + Height * Position;

r.h:= Height;

DrawFromRect(X, Y, @r, SpritesData[Sprite].Texture)

end;

procedure DrawSprite (Sprite: TSprite; X, Y, Frame: LongInt);

var r: TSDL_Rect;

begin

r.x:= 0;

r.w:= SpritesData[Sprite].Width;

r.y:= Frame * SpritesData[Sprite].Height;

r.h:= SpritesData[Sprite].Height;

DrawFromRect(X, Y, @r, SpritesData[Sprite].Texture)

end;

procedure DrawSprite2(Sprite: TSprite; X, Y, FrameX, FrameY: LongInt);

var r: TSDL_Rect;

begin

r.x:= FrameX * SpritesData[Sprite].Width;

r.w:= SpritesData[Sprite].Width;

r.y:= FrameY * SpritesData[Sprite].Height;

r.h:= SpritesData[Sprite].Height;

DrawFromRect(X, Y, @r, SpritesData[Sprite].Texture)

end;

procedure DrawSurfSprite(X, Y, Height, Frame: LongInt; Source: PTexture);

var r: TSDL_Rect;

begin

r.x:= 0;

r.w:= Source^.w;

r.y:= Frame * Height;

r.h:= Height;

DrawFromRect(X, Y, @r, Source)

end;

procedure DrawLand(X, Y: LongInt);

begin

DrawTexture(X, Y, LandTexture)

end;

procedure DrawCentered(X, Top: LongInt; Source: PTexture);

begin

DrawTexture(X - Source^.w div 2, Top, Source)

end;

procedure DrawHedgehog(X, Y: LongInt; Dir: LongInt; Pos, Step: LongWord; Angle: real);

var l, r, t, b: real;

begin

t:= Pos * 32 / HHTexture^.h;