(*

 * Hedgewars, a free turn based strategy game

 * Copyright (c) 2004-2011 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"}

{$IF GLunit = GL}{$DEFINE GLunit:=GL,GLext}{$ENDIF}

unit uStore;

interface

uses sysutils, uConsts, SDLh, GLunit, uTypes;

procedure initModule;

procedure freeModule;

procedure StoreLoad;

procedure StoreRelease;

procedure RenderHealth(var Hedgehog: THedgehog);

procedure AddProgress;

procedure FinishProgress;

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

procedure LoadHedgehogHat(HHGear: PGear; newHat: shortstring);

procedure SetupOpenGL;

procedure SetScale(f: GLfloat);

function  RenderHelpWindow(caption, subcaption, description, extra: ansistring; extracolor: LongInt; iconsurf: PSDL_Surface; iconrect: PSDL_Rect): PTexture;

procedure RenderWeaponTooltip(atype: TAmmoType);

procedure ShowWeaponTooltip(x, y: LongInt);

procedure FreeWeaponTooltip;

procedure MakeCrossHairs;

implementation

uses uMisc, uConsole, uMobile, uVariables, uUtils, uTextures, uRender, uRenderUtils, uCommands, uDebug;

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

var MaxTextureSize: LongInt;

    cGPUVendor: TGPUVendor;

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

var w, h: LongInt;

    tmpsurf: PSDL_Surface;

    clr: TSDL_Color;

    finalRect: TSDL_Rect;

begin

w:= 0; h:= 0; // avoid compiler hints

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

var t: LongInt;

    tmpsurf, texsurf: PSDL_Surface;

    Color, i: Longword;

    s : shortstring;

begin

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

if not FileExists(s+'.png') then 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]:= (RMask or GMask or BMask) and Color;

    if SDL_MustLock(texsurf) then

        SDL_UnlockSurface(texsurf);

    if CrosshairTex <> nil then FreeTexture(CrosshairTex);

    CrosshairTex:= Surface2Tex(texsurf, false);

    SDL_FreeSurface(texsurf)

    end;

SDL_FreeSurface(tmpsurf)

end;

procedure StoreLoad;

var s: shortstring;

    procedure WriteNames(Font: THWFont);

    var t: LongInt;

        i: LongInt;

        r, rr: TSDL_Rect;

        drY: LongInt;

        texsurf, flagsurf, iconsurf: 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

            if Flag = 'hedgewars' then Flag:= 'cpu'

        else if Flag = 'cpu' then

            Flag:= 'hedgewars';

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

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

        if flagsurf = nil then flagsurf:= LoadImage(UserPathz[ptFlags] + '/hedgewars', 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);

        flagsurf:= nil;

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

        SDL_FreeSurface(texsurf);

        texsurf:= nil;

        AIKillsTex := RenderStringTex(inttostr(stats.AIKills), Clan^.Color, fnt16);

        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

                        if (Length(Hat) > 39) and (Copy(Hat,1,8) = 'Reserved') and (Copy(Hat,9,32) = PlayerHash) then

                            LoadHedgehogHat(Gear, 'Reserved/' + Copy(Hat,9,Length(s)-8))

                        else

                            LoadHedgehogHat(Gear, Hat);

                        end

                    end;

        end;

    MissionIcons:= LoadImage(UserPathz[ptGraphics] + '/missions', ifNone);

    if MissionIcons = nil then MissionIcons:= LoadImage(Pathz[ptGraphics] + '/missions', ifCritical);

    iconsurf:= SDL_CreateRGBSurface(SDL_SWSURFACE, 28, 28, 32, RMask, GMask, BMask, AMask);

    if iconsurf <> nil then

        begin

        r.x:= 0;

        r.y:= 0;

        r.w:= 28;

        r.h:= 28;

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

        ropeIconTex:= Surface2Tex(iconsurf, false);

        SDL_FreeSurface(iconsurf);

        iconsurf:= nil;

        end;

    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:= 'Statue';

            texsurf:= LoadImage(UserPathz[ptGraves] + '/' + GraveName, ifTransparent);

            if texsurf = nil then texsurf:= LoadImage(Pathz[ptGraves] + '/' + GraveName, ifTransparent);

            if texsurf = nil then texsurf:= LoadImage(UserPathz[ptGraves] + '/Statue', ifTransparent);

            if texsurf = nil then texsurf:= LoadImage(Pathz[ptGraves] + '/Statue', 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:= UserPathz[ptFonts] + '/' + Name;

        if not FileExists(s) then s:= Pathz[ptFonts] + '/' + Name;

        WriteToConsole(msgLoading + s + ' (' + inttostr(Height) + 'pt)... ');

        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 to match on rq flags?

        if (((cReducedQuality and (rqNoBackground or rqLowRes)) = 0) or   // why rqLowRes?

                (not (ii in [sprSky, sprSkyL, sprSkyR, sprHorizont, sprHorizontL, sprHorizontR]))) and

           (((cReducedQuality and rqPlainSplash) = 0) or ((not (ii in [sprSplash, sprDroplet, sprSDSplash, sprSDDroplet])))) and

           (((cReducedQuality and rqKillFlakes) = 0) or (Theme = 'Snow') or (Theme = 'Christmas') or ((not (ii in [sprFlake, sprSDFlake])))) and

           ((cCloudsNumber > 0) or (ii <> sprCloud)) and

           ((vobCount > 0) or (ii <> sprFlake)) then

        begin

            if AltPath = ptNone then

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

                    begin

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

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

                    end

                else

                    begin

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

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

                    end

            else begin

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

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

                if tmpsurf = nil then tmpsurf:= LoadImage(UserPathz[AltPath] + '/' + 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 getImageDimensions then

		begin

                    imageWidth:= tmpsurf^.w;

                    imageHeight:= tmpsurf^.h

                end;

                if getDimensions then

                begin

                    Width:= tmpsurf^.w;

                    Height:= tmpsurf^.h

                end;

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

                begin

                    Texture:= Surface2Tex(tmpsurf, true);

                    Texture^.Scale:= 2

                end

                else

                begin

                    Texture:= Surface2Tex(tmpsurf, false);

                    // HACK: We should include some sprite attribute to define the texture wrap directions

                    if ((ii = sprWater) or (ii = sprSDWater)) and ((cReducedQuality and (rq2DWater or rqClampLess)) = 0) then

                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

                end;

                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_PRIORITY, priority);

                if saveSurf then

                    Surface:= tmpsurf else SDL_FreeSurface(tmpsurf)

                end

            else

                Surface:= nil

        end;

AddProgress;

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

if tmpsurf = nil then 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

        TryDo(trAmmo[NameId] <> '','No default text/translation found for ammo type #' + intToStr(ord(ai)) + '!',true);

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

        TryDo(tmpsurf <> nil,'Name-texture creation for ammo type #' + intToStr(ord(ai)) + ' failed!',true);

        tmpsurf:= doSurfaceConversion(tmpsurf);

        if (NameTex <> nil) then

            FreeTexture(NameTex);

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

    if (CountTexz[i] <> nil) then

        FreeTexture(CountTexz[i]);

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

    SDL_FreeSurface(tmpsurf)

end;

AddProgress;

{$IFDEF SDL_IMAGE_NEWER}

IMG_Quit();

{$ENDIF}

end;

procedure StoreRelease;

var ii: TSprite;

    ai: TAmmoType;

    i, t: LongInt;

begin

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

    begin

        FreeTexture(SpritesData[ii].Texture);

        SpritesData[ii].Texture:= nil;

        if SpritesData[ii].Surface <> nil then

            SDL_FreeSurface(SpritesData[ii].Surface);

        SpritesData[ii].Surface:= nil;

    end;

    SDL_FreeSurface(MissionIcons);

    FreeTexture(ropeIconTex);

    FreeTexture(HHTexture);

    FreeTexture(PauseTexture);

    FreeTexture(ConfirmTexture);

    FreeTexture(SyncTexture);

    // free all ammo name textures

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

    begin

        FreeTexture(Ammoz[ai].NameTex);

    end;

    // free all count textures

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

    begin

        FreeTexture(CountTexz[i]);

    end;

    // free all team and hedgehog textures

    for t:= 0 to Pred(TeamsCount) do

    begin

        if TeamsArray[t] <> nil then

        begin

            FreeTexture(TeamsArray[t]^.NameTagTex);

            FreeTexture(TeamsArray[t]^.CrosshairTex);

            FreeTexture(TeamsArray[t]^.GraveTex);

            FreeTexture(TeamsArray[t]^.HealthTex);

            FreeTexture(TeamsArray[t]^.AIKillsTex);

            FreeTexture(TeamsArray[t]^.FlagTex);

            for i:= 0 to cMaxHHIndex do

            begin

                FreeTexture(TeamsArray[t]^.Hedgehogs[i].NameTagTex);

                FreeTexture(TeamsArray[t]^.Hedgehogs[i].HealthTagTex);

                FreeTexture(TeamsArray[t]^.Hedgehogs[i].HatTex);

            end;

        end;

    end;

{$IFNDEF S3D_DISABLED}

    if (cStereoMode = smHorizontal) or (cStereoMode = smVertical) or (cStereoMode = smAFR) then

    begin

        glDeleteTextures(1, @texl);

        glDeleteRenderbuffersEXT(1, @depthl);

        glDeleteFramebuffersEXT(1, @framel);

        glDeleteTextures(1, @texr);

        glDeleteRenderbuffersEXT(1, @depthr);

        glDeleteFramebuffersEXT(1, @framer)

    end

{$ENDIF}

end;

procedure RenderHealth(var Hedgehog: THedgehog);

var s: shortstring;

begin

    str(Hedgehog.Gear^.Health, s);

    if Hedgehog.HealthTagTex <> nil then

        FreeTexture(Hedgehog.HealthTagTex);

    Hedgehog.HealthTagTex:= RenderStringTex(s, Hedgehog.Team^.Clan^.Color, fnt16)

end;

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

var tmpsurf: PSDL_Surface;

    s: shortstring;

begin

    WriteToConsole(msgLoading + filename + '.png [flags: ' + inttostr(imageFlags) + '] ');

    s:= filename + '.png';

    tmpsurf:= IMG_Load(Str2PChar(s));

    if tmpsurf = nil then

    begin

        OutError(msgFailed, (imageFlags and ifCritical) <> 0);

        exit(nil)

    end;

    if ((imageFlags and ifIgnoreCaps) = 0) and ((tmpsurf^.w > MaxTextureSize) or (tmpsurf^.h > MaxTextureSize)) then

    begin

        SDL_FreeSurface(tmpsurf);

        OutError(msgFailedSize, (imageFlags and ifCritical) <> 0);

        // dummy surface to replace non-critical textures that failed to load due to their size

        exit(SDL_CreateRGBSurface(SDL_SWSURFACE, 2, 2, 32, RMask, GMask, BMask, AMask));

    end;

    tmpsurf:= doSurfaceConversion(tmpsurf);