(*

 * Hedgewars, a free turn based strategy 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

 *)

{$INCLUDE "options.inc"}

unit uStore;

interface

uses sysutils, uConsts, uTeams, SDLh, uFloat,

{$IFDEF GLES11}

	gles11;

{$ELSE}

	GL, GLext;

{$ENDIF}

var PixelFormat: PSDL_PixelFormat;

    SDLPrimSurface: PSDL_Surface;

    PauseTexture,

    SyncTexture,

    ConfirmTexture: PTexture;

    cScaleFactor: GLfloat;

    SupportNPOTT: Boolean;

    Step: LongInt;

    squaresize : LongInt;

    numsquares : LongInt;

    ProgrTex: PTexture;

procedure init_uStore;

procedure free_uStore;

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 DrawSpriteClipped(Sprite: TSprite; X, Y, TopY, RightX, BottomY, LeftX: LongInt);

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

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

procedure DrawTextureF(Texture: PTexture; Scale: GLfloat; X, Y, Frame, Dir, Frames: LongInt);

procedure DrawRotatedTextureF(Texture: PTexture; Scale, OffsetX, OffsetY: GLfloat; X, Y, Frame, Dir, Frames: LongInt; Angle: real);

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

procedure DrawFillRect(r: TSDL_Rect);

function  CheckCJKFont(s: string; font: THWFont): THWFont;

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

function  RenderSpeechBubbleTex(s: string; SpeechType: Longword; font: THWFont): PTexture;

procedure flipSurface(Surface: PSDL_Surface; Vertical: Boolean);

//procedure rotateSurface(Surface: PSDL_Surface);

procedure copyRotatedSurface(src, dest: PSDL_Surface); // this is necessary since width/height are read only in SDL

procedure copyToXY(src, dest: PSDL_Surface; destX, destY: Integer);

procedure RenderHealth(var Hedgehog: THedgehog);

procedure AddProgress;

procedure FinishProgress;

function  LoadImage(const filename: string; imageFlags: LongInt): PSDL_Surface;

procedure SetupOpenGL;

procedure SetScale(f: GLfloat);

procedure RenderWeaponTooltip(atype: TAmmoType);

procedure ShowWeaponTooltip(x, y: LongInt);

procedure FreeWeaponTooltip;

implementation

uses uMisc, uConsole, uLand, uLocale, uWorld{$IFDEF IPHONEOS}, PascalExports{$ENDIF};

type TGPUVendor = (gvUnknown, gvNVIDIA, gvATI, gvIntel, gvApple);

var HHTexture: PTexture;

    MaxTextureSize: Integer;

    cGPUVendor: TGPUVendor;

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;

    finalRect: TSDL_Rect;

begin

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

finalRect.x:= X;

finalRect.y:= Y;

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

finalRect.h:= h + FontBorder * 2;

DrawRoundRect(@finalRect, cWhiteColor, endian(cNearBlackColorChannels.value), Surface, true);

clr.r:= (Color shr 16) and $FF;

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

clr.b:= Color and $FF;

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

finalRect.x:= X + FontBorder + 2;

finalRect.y:= Y + FontBorder;

SDLTry(tmpsurf <> nil, true);

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

SDL_FreeSurface(tmpsurf);

finalRect.x:= X;

finalRect.y:= Y;

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

finalRect.h:= h + FontBorder * 2;

WriteInRoundRect:= finalRect;

end;

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

var w, h: LongInt;

    tmpsurf: PSDL_Surface;

    clr: TSDL_Color;

    finalRect: TSDL_Rect;

begin

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

finalRect.x:= X + FontBorder + 2;

finalRect.y:= Y + FontBorder;

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

finalRect.h:= h + FontBorder * 2;

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

tmpsurf:= doSurfaceConversion(tmpsurf);

SDLTry(tmpsurf <> nil, true);

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

SDL_FreeSurface(tmpsurf);

finalRect.x:= X;

finalRect.y:= Y;

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

finalRect.h:= h + FontBorder * 2;

WriteInRect:= finalRect

end;

procedure StoreLoad;

var s: string;

	procedure WriteNames(Font: THWFont);

	var t: LongInt;

		i: LongInt;

		r, rr: TSDL_Rect;

		drY: LongInt;

		texsurf, flagsurf: PSDL_Surface;

	begin

	r.x:= 0;

	r.y:= 0;

	drY:= - 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, cNearBlackColorChannels.value, 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, false);

		SDL_FreeSurface(texsurf);

		r.x:= 0;

		r.y:= 0;

		r.w:= 32;

		r.h:= 32;

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

		r.w:= 26;

		r.h:= 19;

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

		// overwrite flag for cpu teams and keep players from using it

		if (Hedgehogs[0].Gear <> nil) and (Hedgehogs[0].BotLevel > 0) then

			Flag:= 'cpu'

		else if Flag = 'cpu' then

			Flag:= 'hedgewars';

		flagsurf:= LoadImage(Pathz[ptFlags] + '/' + Flag, ifNone);

		if flagsurf = nil then

			flagsurf:= LoadImage(Pathz[ptFlags] + '/hedgewars', ifNone);

		TryDo(flagsurf <> nil, 'Failed to load flag "' + Flag + '" as well as the default flag', true);

		copyToXY(flagsurf, texsurf, 2, 2);

		SDL_FreeSurface(flagsurf);

		// restore black border pixels inside the flag

		PLongwordArray(texsurf^.pixels)^[32 * 2 +  2]:= cNearBlackColor;

		PLongwordArray(texsurf^.pixels)^[32 * 2 + 23]:= cNearBlackColor;

		PLongwordArray(texsurf^.pixels)^[32 * 16 +  2]:= cNearBlackColor;

		PLongwordArray(texsurf^.pixels)^[32 * 16 + 23]:= cNearBlackColor;

		FlagTex:= Surface2Tex(texsurf, false);

		dec(drY, r.h + 2);

		DrawHealthY:= drY;

		for i:= 0 to 7 do

			with Hedgehogs[i] do

				if Gear <> nil then

					begin

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

					if Hat <> 'NoHat' then

						begin

						texsurf:= LoadImage(Pathz[ptHats] + '/' + Hat, ifNone);

						if texsurf <> nil then

							begin

							HatTex:= Surface2Tex(texsurf, true);

							SDL_FreeSurface(texsurf)

							end

						end

					end;

		end;

	end;

	procedure MakeCrossHairs;

	var t: LongInt;

		tmpsurf, texsurf: PSDL_Surface;

		Color, i: Longword;

	begin

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

	tmpsurf:= LoadImage(s, ifAlpha or ifCritical);

	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] = AMask then PLongwordArray(texsurf^.pixels)^[i]:= 0;

		if SDL_MustLock(texsurf) then

			SDL_UnlockSurface(texsurf);

		CrosshairTex:= Surface2Tex(texsurf, false);

		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, ifCritical or ifTransparent);

			GraveTex:= Surface2Tex(texsurf, false);

			SDL_FreeSurface(texsurf)

			end

	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;

WriteNames(fnt16);

MakeCrossHairs;

LoadGraves;

AddProgress;

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

	with SpritesData[ii] do

        // FIXME - add a sprite attribute

        if (not cReducedQuality) or (not (ii in [sprSky, sprSkyL, sprSkyR, sprHorizont, sprHorizontL, sprHorizontR, sprFlake])) then // FIXME: hack

		begin

			if AltPath = ptNone then

				if ii in [sprHorizontL, sprHorizontR, sprSkyL, sprSkyR] then // FIXME: hack

					tmpsurf:= LoadImage(Pathz[Path] + '/' + FileName, ifAlpha or ifTransparent or ifLowRes)

				else

					tmpsurf:= LoadImage(Pathz[Path] + '/' + FileName, ifAlpha or ifTransparent or ifCritical or ifLowRes)

			else begin

				tmpsurf:= LoadImage(Pathz[Path] + '/' + FileName, ifAlpha or ifTransparent);

				if tmpsurf = nil then

					tmpsurf:= LoadImage(Pathz[AltPath] + '/' + FileName, ifAlpha or ifCritical or ifTransparent);

				end;

			if tmpsurf <> nil then

			begin

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

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

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

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

				if (ii in [sprSky, sprSkyL, sprSkyR, sprHorizont, sprHorizontL, sprHorizontR]) then

					Texture:= Surface2Tex(tmpsurf, true)

				else

					begin

					Texture:= Surface2Tex(tmpsurf, false);

					if (ii = sprWater) and not cReducedQuality then // HACK: We should include some sprite attribute to define the texture wrap directions

					begin

						glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

					end;

				end;

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

				end

			else

				Surface:= nil

		end;

AddProgress;

tmpsurf:= LoadImage(Pathz[ptGraphics] + '/' + cHHFileName, ifAlpha or ifCritical or ifTransparent);

HHTexture:= Surface2Tex(tmpsurf, false);

SDL_FreeSurface(tmpsurf);

InitHealth;

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

ConfirmTexture:= RenderStringTex(trmsg[sidConfirm], cYellowColor, fntBig);

SyncTexture:= RenderStringTex(trmsg[sidSync], cYellowColor, fntBig);

AddProgress;

// name of weapons in ammo menu

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

	with Ammoz[ai] do

		begin

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

		tmpsurf:= doSurfaceConversion(tmpsurf);

		NameTex:= Surface2Tex(tmpsurf, false);

		SDL_FreeSurface(tmpsurf)

		end;

// number of weapons in ammo menu

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

	begin

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

	tmpsurf:= doSurfaceConversion(tmpsurf);

	CountTexz[i]:= Surface2Tex(tmpsurf, false);

	SDL_FreeSurface(tmpsurf)

	end;

{$IFDEF DUMP}

//not working anymore, where are LandSurface and StoreSurface defined?

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

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

{$ENDIF}

AddProgress;

{$IFDEF SDL_IMAGE_NEWER}

IMG_Quit();

{$ENDIF}

end;

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

var rr: TSDL_Rect;

    _l, _r, _t, _b: real;

    VertexBuffer, TextureBuffer: array [0..3] of TVertex2f;

begin

if (SourceTexture^.h = 0) or (SourceTexture^.w = 0) then exit;

rr.x:= X;

rr.y:= Y;

rr.w:= r^.w;

rr.h:= r^.h;

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

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

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

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

glBindTexture(GL_TEXTURE_2D, SourceTexture^.id);

VertexBuffer[0].X:= X;

VertexBuffer[0].Y:= Y;

VertexBuffer[1].X:= rr.w + X;

VertexBuffer[1].Y:= Y;

VertexBuffer[2].X:= rr.w + X;

VertexBuffer[2].Y:= rr.h + Y;

VertexBuffer[3].X:= X;

VertexBuffer[3].Y:= rr.h + Y;

TextureBuffer[0].X:= _l;

TextureBuffer[0].Y:= _t;

TextureBuffer[1].X:= _r;

TextureBuffer[1].Y:= _t;

TextureBuffer[2].X:= _r;

TextureBuffer[2].Y:= _b;

TextureBuffer[3].X:= _l;

TextureBuffer[3].Y:= _b;

glEnableClientState(GL_VERTEX_ARRAY);

glEnableClientState(GL_TEXTURE_COORD_ARRAY);

glVertexPointer(2, GL_FLOAT, 0, @VertexBuffer[0]);

glTexCoordPointer(2, GL_FLOAT, 0, @TextureBuffer[0]);

glDrawArrays(GL_TRIANGLE_FAN, 0, Length(VertexBuffer));

glDisableClientState(GL_TEXTURE_COORD_ARRAY);

glDisableClientState(GL_VERTEX_ARRAY)

end;

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

begin

glPushMatrix;

glTranslatef(X, Y, 0);