1051 lines
25 KiB
Ucode
1051 lines
25 KiB
Ucode
Class GUIStyleBase extends Object
|
|
abstract;
|
|
|
|
`include(Build.uci)
|
|
`include(Logger.uci)
|
|
|
|
var Texture2D ItemTex;
|
|
var array<Texture2D> BorderTextures, ArrowTextures, ButtonTextures, TabTextures, ItemBoxTextures, PerkBox, CheckBoxTextures, ProgressBarTextures, SliderTextures;
|
|
var Texture2D ScrollTexture, FavoriteIcon, BankNoteIcon;
|
|
|
|
var SoundCue MenuDown, MenuDrag, MenuEdit, MenuFade, MenuClick, MenuHover, MenuUp;
|
|
|
|
var() byte MaxFontScale;
|
|
var float DefaultHeight; // Default font text size.
|
|
var transient Canvas Canvas;
|
|
var transient KF2GUIController Owner;
|
|
var transient ScoreboardExtHUD HUDOwner;
|
|
|
|
var Font MainFont, NumberFont, InfiniteFont;
|
|
var Color BlurColor, BlurColor2;
|
|
|
|
enum ECornerPosition
|
|
{
|
|
ECP_TopLeft,
|
|
ECP_TopRight,
|
|
ECP_BottomLeft,
|
|
ECP_BottomRight
|
|
};
|
|
|
|
enum ECornerShape
|
|
{
|
|
ECS_Corner,
|
|
ECS_BeveledCorner,
|
|
ECS_VerticalCorner,
|
|
ECS_HorisontalCorner
|
|
};
|
|
|
|
struct FColorInfo
|
|
{
|
|
var name Code;
|
|
var Color Color;
|
|
};
|
|
var array<FColorInfo> ColorCodes;
|
|
|
|
struct FTexturePreCache
|
|
{
|
|
var string Path;
|
|
var Texture2D Tex;
|
|
};
|
|
var array<FTexturePreCache> PrecachedTextures;
|
|
|
|
function InitStyle()
|
|
{
|
|
local FColorInfo ColorInfo;
|
|
|
|
ItemTex=Texture2D(DynamicLoadObject("UI_LevelChevrons_TEX.UI_LevelChevron_Icon_02", class'Texture2D'));
|
|
if (ItemTex == None)
|
|
ItemTex=Texture2D'EngineMaterials.DefaultWhiteGrid';
|
|
|
|
NumberFont = Font(DynamicLoadObject("UI_Canvas_Fonts.Font_General", class'Font'));
|
|
|
|
BlurColor = MakeColor(60, 60, 60, 220);
|
|
BlurColor2 = MakeColor(40, 40, 40, 140);
|
|
|
|
ColorInfo.Code='Q';
|
|
ColorInfo.Color = MakeColor(0, 140, 0,255); // Dark Green
|
|
ColorCodes.AddItem(ColorInfo);
|
|
|
|
ColorInfo.Code='E';
|
|
ColorInfo.Color = MakeColor(210, 180, 140, 255); // Tan
|
|
ColorCodes.AddItem(ColorInfo);
|
|
|
|
ColorInfo.Code='R';
|
|
ColorInfo.Color = MakeColor(128, 0,0, 255); // Dark Red
|
|
ColorCodes.AddItem(ColorInfo);
|
|
|
|
ColorInfo.Code='T';
|
|
ColorInfo.Color = MakeColor(153, 102, 204, 255); // Purple
|
|
ColorCodes.AddItem(ColorInfo);
|
|
|
|
ColorInfo.Code='U';
|
|
ColorInfo.Color = MakeColor(128, 128, 128, 255); // Dark Gray
|
|
ColorCodes.AddItem(ColorInfo);
|
|
|
|
ColorInfo.Code='I';
|
|
ColorInfo.Color = MakeColor(255, 170, 0,255); // Orange
|
|
ColorCodes.AddItem(ColorInfo);
|
|
|
|
ColorInfo.Code='O';
|
|
ColorInfo.Color = MakeColor(255, 204, 153, 255); // Cream
|
|
ColorCodes.AddItem(ColorInfo);
|
|
|
|
ColorInfo.Code='P';
|
|
ColorInfo.Color = MakeColor(209, 216, 168, 255); // Olive
|
|
ColorCodes.AddItem(ColorInfo);
|
|
|
|
ColorInfo.Code='A';
|
|
ColorInfo.Color = MakeColor(204, 51, 51, 255); // Brick
|
|
ColorCodes.AddItem(ColorInfo);
|
|
|
|
ColorInfo.Code='S';
|
|
ColorInfo.Color = MakeColor(153, 102, 51, 255); // Brown
|
|
ColorCodes.AddItem(ColorInfo);
|
|
|
|
ColorInfo.Code='D';
|
|
ColorInfo.Color = MakeColor(0, 204, 0,255); // Green
|
|
ColorCodes.AddItem(ColorInfo);
|
|
|
|
ColorInfo.Code='F';
|
|
ColorInfo.Color = MakeColor(238, 238, 51, 255); // Yellow
|
|
ColorCodes.AddItem(ColorInfo);
|
|
|
|
ColorInfo.Code='G';
|
|
ColorInfo.Color = MakeColor(200, 0,0, 255); // Red
|
|
ColorCodes.AddItem(ColorInfo);
|
|
|
|
ColorInfo.Code='H';
|
|
ColorInfo.Color = MakeColor(153, 153, 255, 255); // Blue
|
|
ColorCodes.AddItem(ColorInfo);
|
|
|
|
ColorInfo.Code='J';
|
|
ColorInfo.Color = MakeColor(192, 192, 192, 255); // Silver
|
|
ColorCodes.AddItem(ColorInfo);
|
|
|
|
ColorInfo.Code='K';
|
|
ColorInfo.Color = MakeColor(255, 204, 0,255); // Gold
|
|
ColorCodes.AddItem(ColorInfo);
|
|
|
|
ColorInfo.Code='C';
|
|
ColorInfo.Color = MakeColor(255, 255, 255, 255); // White
|
|
ColorCodes.AddItem(ColorInfo);
|
|
|
|
ColorInfo.Code='V';
|
|
ColorInfo.Color = MakeColor(0, 191, 255, 255); // Sky Blue
|
|
ColorCodes.AddItem(ColorInfo);
|
|
|
|
ColorInfo.Code='B';
|
|
ColorInfo.Color = MakeColor(204, 204, 204, 255); // Gray
|
|
ColorCodes.AddItem(ColorInfo);
|
|
|
|
ColorInfo.Code='N';
|
|
ColorInfo.Color = MakeColor(0, 128, 255, 255); // Dark Sky Blue
|
|
ColorCodes.AddItem(ColorInfo);
|
|
|
|
ColorInfo.Code='M';
|
|
ColorInfo.Color = MakeColor(18, 18, 18, 255); // Black
|
|
ColorCodes.AddItem(ColorInfo);
|
|
}
|
|
|
|
function RenderFramedWindow(KFGUI_FloatingWindow P);
|
|
function RenderWindow(KFGUI_Page P);
|
|
function RenderToolTip(KFGUI_Tooltip TT);
|
|
function RenderButton(KFGUI_Button B);
|
|
function RenderScrollBar(KFGUI_ScrollBarBase S);
|
|
function RenderColumnHeader(KFGUI_ColumnTop C, float XPos, float Width, int Index, bool bFocus, bool bSort);
|
|
function RenderRightClickMenu(KFGUI_RightClickMenu C);
|
|
function RenderCheckbox(KFGUI_CheckBox C);
|
|
function RenderComboBox(KFGUI_ComboBox C);
|
|
function RenderComboList(KFGUI_ComboSelector C);
|
|
|
|
function Font PickFont(out float Scaler, optional bool bNumbersOnly, optional bool bInfinite)
|
|
{
|
|
Scaler = GetFontScaler();
|
|
|
|
if (bNumbersOnly)
|
|
return NumberFont;
|
|
else if (bInfinite)
|
|
return InfiniteFont;
|
|
|
|
return MainFont;
|
|
}
|
|
|
|
function PickDefaultFontSize(float YRes)
|
|
{
|
|
local int XL, YL;
|
|
local string S;
|
|
|
|
S="ABC";
|
|
PickFont(YRes).GetStringHeightAndWidth(S, YL, XL);
|
|
|
|
DefaultHeight=float(YL)*YRes;
|
|
}
|
|
final function float ScreenScale(float Size, optional float MaxRes=1080.f)
|
|
{
|
|
return Size * ( HUDOwner.SizeY / MaxRes);
|
|
}
|
|
final function float GetFontScaler(optional float Scaler=0.750f, optional float Min=0.175f, optional float Max=1.0f)
|
|
{
|
|
return FClamp((HUDOwner.SizeY / 1080.f) * Scaler, Min, Max);
|
|
}
|
|
final function DrawText(coerce string S)
|
|
{
|
|
local float Scale;
|
|
|
|
Canvas.Font=PickFont(Scale);
|
|
Canvas.DrawText(S, ,Scale, Scale);
|
|
}
|
|
final function DrawCenteredText(coerce string S, float X, float Y, optional float Scale=1.f, optional bool bVertical, optional bool bUseOutline)
|
|
{
|
|
local float XL, YL;
|
|
|
|
Canvas.TextSize(S, XL, YL);
|
|
if (bVertical)
|
|
Canvas.SetPos(X, Y-(YL*Scale*0.5));
|
|
else Canvas.SetPos(X-(XL*Scale*0.5), Y);
|
|
|
|
if (bUseOutline)
|
|
DrawTextShadow(S, Canvas.CurX, Canvas.CurY, 1, Scale);
|
|
else Canvas.DrawText(S, ,Scale, Scale);
|
|
}
|
|
final function string StripColorTags(coerce string S)
|
|
{
|
|
local int Pos;
|
|
|
|
Pos = InStr(S, "\\c");
|
|
while (Pos != INDEX_NONE)
|
|
{
|
|
S = Left(S, Pos) $ Mid(S, Pos+3);
|
|
Pos = InStr(S, "\\c");
|
|
}
|
|
|
|
return S;
|
|
}
|
|
final function DrawColoredText(coerce string S, float X, float Y, optional float Scale=1.f, optional bool bUseOutline)
|
|
{
|
|
local float XL, YL;
|
|
local int i, Index;
|
|
local array<string> SArray;
|
|
local string T, PrevT;
|
|
local Color TextColor;
|
|
|
|
if (InStr(S, "\\c") == INDEX_NONE)
|
|
{
|
|
if (bUseOutline)
|
|
DrawTextShadow(S, X, Y, 1, Scale);
|
|
else
|
|
{
|
|
Canvas.SetPos(X, Y);
|
|
Canvas.DrawText(S, ,Scale, Scale);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SArray = SplitString(S, "\\c");
|
|
|
|
PrevT = Left(S, InStr(S, "\\c"));
|
|
if (Len(PrevT) > 0)
|
|
{
|
|
Canvas.TextSize(PrevT, XL, YL, Scale, Scale);
|
|
|
|
if (bUseOutline)
|
|
DrawTextShadow(PrevT, X, Y, 1, Scale);
|
|
else
|
|
{
|
|
Canvas.SetPos(X, Y);
|
|
Canvas.DrawText(PrevT, ,Scale, Scale);
|
|
}
|
|
}
|
|
|
|
for (i=0; i < SArray.Length; i++)
|
|
{
|
|
T = SArray[i];
|
|
if (i > 0 || Left(S, 2)~="\\c")
|
|
{
|
|
Index = ColorCodes.Find('Code', name(Left(T, 1)));
|
|
if (Index != INDEX_NONE)
|
|
TextColor = ColorCodes[Index].Color;
|
|
else TextColor = class'HUD'.default.WhiteColor;
|
|
|
|
TextColor.A = Canvas.DrawColor.A;
|
|
|
|
T = Mid(T, 1);
|
|
}
|
|
|
|
Canvas.DrawColor = TextColor;
|
|
Canvas.TextSize(T, XL, YL, Scale, Scale);
|
|
|
|
if (bUseOutline)
|
|
DrawTextShadow(T, X, Y, 1, Scale);
|
|
else
|
|
{
|
|
Canvas.SetPos(X, Y);
|
|
Canvas.DrawText(T, ,Scale, Scale);
|
|
}
|
|
|
|
X += XL;
|
|
}
|
|
}
|
|
}
|
|
final function DrawTextBlurry(coerce string S, float X, float Y, optional float Scale=1.f)
|
|
{
|
|
local Color OldDrawColor;
|
|
|
|
OldDrawColor = Canvas.DrawColor;
|
|
BlurColor.A = OldDrawColor.A * 0.85;
|
|
BlurColor2.A = OldDrawColor.A * 0.55;
|
|
|
|
Canvas.DrawColor = BlurColor;
|
|
Canvas.SetPos(X + Owner.FontBlurX, Y + Owner.FontBlurY);
|
|
Canvas.DrawText(S, ,Scale, Scale);
|
|
|
|
Canvas.DrawColor = BlurColor2;
|
|
Canvas.SetPos(X + Owner.FontBlurX2, Y + Owner.FontBlurY2);
|
|
Canvas.DrawText(S, ,Scale, Scale);
|
|
|
|
Canvas.DrawColor = OldDrawColor;
|
|
Canvas.SetPos(X, Y);
|
|
Canvas.DrawText(S, ,Scale, Scale);
|
|
}
|
|
final function DrawTextOutline(coerce string S, float X, float Y, int Size, Color OutlineColor, optional float Scale=1.f, optional FontRenderInfo FRI)
|
|
{
|
|
local Color OldDrawColor;
|
|
local int XS, YS, Steps;
|
|
|
|
OldDrawColor = Canvas.DrawColor;
|
|
OutlineColor.A = OldDrawColor.A;
|
|
|
|
Size += 1;
|
|
Steps = (Size * 2) / 3;
|
|
if (Steps < 1 )
|
|
{
|
|
Steps = 1;
|
|
}
|
|
|
|
Canvas.DrawColor = OutlineColor;
|
|
for (XS = -Size; XS <= Size; XS+=Steps)
|
|
{
|
|
for (YS = -Size; YS <= Size; YS+=Steps)
|
|
{
|
|
Canvas.SetPos(X + XS, Y + YS);
|
|
Canvas.DrawText(S, , Scale, Scale, FRI);
|
|
}
|
|
}
|
|
|
|
Canvas.DrawColor = OldDrawColor;
|
|
Canvas.SetPos(X, Y);
|
|
Canvas.DrawText(S, , Scale, Scale, FRI);
|
|
}
|
|
final function DrawTextShadow(coerce string S, float X, float Y, float ShadowSize, optional float Scale=1.f)
|
|
{
|
|
local Color OldDrawColor;
|
|
|
|
OldDrawColor = Canvas.DrawColor;
|
|
|
|
Canvas.SetPos(X + ShadowSize, Y + ShadowSize);
|
|
Canvas.SetDrawColor(0, 0, 0, OldDrawColor.A);
|
|
Canvas.DrawText(S, , Scale, Scale);
|
|
|
|
Canvas.SetPos(X, Y);
|
|
Canvas.DrawColor = OldDrawColor;
|
|
Canvas.DrawText(S, , Scale, Scale);
|
|
}
|
|
final function DrawTexturedString(coerce string S, float X, float Y, optional float TextScaler=1.f, optional FontRenderInfo FRI, optional bool bUseOutline, optional bool bOnlyTexture)
|
|
{
|
|
local Texture2D Mat;
|
|
local string D;
|
|
local float XL, YL;
|
|
local int i, j;
|
|
local Color OrgC;
|
|
|
|
OrgC = Canvas.DrawColor;
|
|
|
|
Mat = FindNextTexture(S);
|
|
while (Mat != None)
|
|
{
|
|
i = InStr(S, "<TEXTURE");
|
|
j = InStr(S, ">");
|
|
|
|
D = Left(S, i);
|
|
S = Mid(S, j+2);
|
|
|
|
if (!bOnlyTexture)
|
|
{
|
|
Canvas.TextSize(StripColorTags(D), XL, YL, TextScaler, TextScaler);
|
|
DrawColoredText(D, X,Y, TextScaler, bUseOutline);
|
|
|
|
X += XL;
|
|
}
|
|
else Canvas.TextSize("W", XL, YL, TextScaler, TextScaler);
|
|
|
|
Canvas.DrawColor = class'HUD'.default.WhiteColor;
|
|
Canvas.DrawColor.A = OrgC.A;
|
|
|
|
Canvas.SetPos(X, Y+(Owner.HUDOwner.ScaledBorderSize/2));
|
|
Canvas.DrawRect(YL-Owner.HUDOwner.ScaledBorderSize, YL-Owner.HUDOwner.ScaledBorderSize, Mat);
|
|
|
|
X += YL-Owner.HUDOwner.ScaledBorderSize;
|
|
|
|
Canvas.DrawColor = OrgC;
|
|
Mat = FindNextTexture(S);
|
|
}
|
|
|
|
DrawColoredText(S, X,Y, TextScaler, bUseOutline);
|
|
}
|
|
final function Texture2D FindNextTexture(out string S)
|
|
{
|
|
local int i, j;
|
|
local string Path;
|
|
local Texture2D Tex;
|
|
local FTexturePreCache Cache;
|
|
|
|
Path = S;
|
|
i = InStr(Path, "<Icon>");
|
|
if (i == INDEX_NONE)
|
|
return None;
|
|
|
|
j = InStr(Path, " </Icon>");
|
|
S = Left(Path, i)$"<TEXTURE>"$Mid(Path, j+6);
|
|
Path = Mid(Path, i+6, j-(i+6));
|
|
|
|
i = PrecachedTextures.Find('Path', Path);
|
|
if (i != INDEX_NONE)
|
|
return PrecachedTextures[i].Tex;
|
|
|
|
Tex = Texture2D(FindObject(Path, class'Texture2D'));
|
|
if (Tex != None)
|
|
{
|
|
Cache.Path = Path;
|
|
Cache.Tex = Tex;
|
|
PrecachedTextures.AddItem(Cache);
|
|
|
|
return Tex;
|
|
}
|
|
|
|
Cache.Path = Path;
|
|
Cache.Tex = Texture2D(DynamicLoadObject(Path, class'Texture2D'));
|
|
PrecachedTextures.AddItem(Cache);
|
|
|
|
return Cache.Tex;
|
|
}
|
|
final function string StripTextureFromString(string S, optional bool bNoStringAdd)
|
|
{
|
|
local int i, j;
|
|
|
|
while (true)
|
|
{
|
|
i = InStr(S, "<Icon>");
|
|
if (i == INDEX_NONE)
|
|
break;
|
|
|
|
j = InStr(S, "</Icon>");
|
|
S = Left(S, i)$(bNoStringAdd ? "" : "W")$Mid(S, j+Len("</Icon>"));
|
|
}
|
|
|
|
return StripColorTags(S);
|
|
}
|
|
final function string GetTimeString(int Seconds)
|
|
{
|
|
local int Minutes, Hours;
|
|
local string Time;
|
|
|
|
if (Seconds > 3600)
|
|
{
|
|
Hours = Seconds / 3600;
|
|
Seconds -= Hours * 3600;
|
|
|
|
Time = Hours$":";
|
|
}
|
|
Minutes = Seconds / 60;
|
|
Seconds -= Minutes * 60;
|
|
|
|
if (Minutes >= 10)
|
|
Time = Time $ Minutes $ ":";
|
|
else Time = Time $ "0" $ Minutes $ ":";
|
|
|
|
if (Seconds >= 10)
|
|
Time = Time $ Seconds;
|
|
else Time = Time $ "0" $ Seconds;
|
|
|
|
return Time;
|
|
}
|
|
|
|
final function DrawCornerTexNU(int SizeX, int SizeY, byte Dir ) // Draw non-uniform corner.
|
|
{
|
|
switch (Dir)
|
|
{
|
|
case 0: // Up-left
|
|
Canvas.DrawTile(ItemTex, SizeX, SizeY, 77, 15, -66, 58);
|
|
break;
|
|
case 1: // Up-right
|
|
Canvas.DrawTile(ItemTex, SizeX, SizeY, 11, 15, 66, 58);
|
|
break;
|
|
case 2: // Down-left
|
|
Canvas.DrawTile(ItemTex, SizeX, SizeY, 77, 73, -66, -58);
|
|
break;
|
|
default: // Down-right
|
|
Canvas.DrawTile(ItemTex, SizeX, SizeY, 11, 73, 66, -58);
|
|
}
|
|
}
|
|
final function DrawCornerTex(int Size, byte Dir)
|
|
{
|
|
switch (Dir)
|
|
{
|
|
case 0: // Up-left
|
|
Canvas.DrawTile(ItemTex, Size, Size, 77, 15, -66, 58);
|
|
break;
|
|
case 1: // Up-right
|
|
Canvas.DrawTile(ItemTex, Size, Size, 11, 15, 66, 58);
|
|
break;
|
|
case 2: // Down-left
|
|
Canvas.DrawTile(ItemTex, Size, Size, 77, 73, -66, -58);
|
|
break;
|
|
default: // Down-right
|
|
Canvas.DrawTile(ItemTex, Size, Size, 11, 73, 66, -58);
|
|
}
|
|
}
|
|
final function DrawWhiteBox(float XS, float YS, optional bool bClip)
|
|
{
|
|
Canvas.DrawTile(ItemTex, XS, YS, 19, 45, 1,1, ,bClip);
|
|
}
|
|
|
|
final function DrawCornerSmart(out float X, float Y, int Edge, int CornerPosition, int CornerShape)
|
|
{
|
|
switch (CornerPosition)
|
|
{
|
|
case ECP_TopLeft:
|
|
switch (CornerShape)
|
|
{
|
|
case ECS_Corner:
|
|
return;
|
|
case ECS_BeveledCorner:
|
|
Canvas.SetPos(X, Y);
|
|
DrawCornerTex(Edge, 0);
|
|
X += Edge;
|
|
return;
|
|
case ECS_VerticalCorner:
|
|
Canvas.SetPos(X, Y - Edge);
|
|
DrawCornerTex(Edge, 1);
|
|
X += Edge;
|
|
return;
|
|
case ECS_HorisontalCorner:
|
|
Canvas.SetPos(X - Edge, Y);
|
|
DrawCornerTex(Edge, 2);
|
|
return;
|
|
}
|
|
case ECP_TopRight:
|
|
switch (CornerShape)
|
|
{
|
|
case ECS_Corner:
|
|
return;
|
|
case ECS_BeveledCorner:
|
|
Canvas.SetPos(X, Y);
|
|
DrawCornerTex(Edge, 1);
|
|
X += Edge;
|
|
return;
|
|
case ECS_VerticalCorner:
|
|
Canvas.SetPos(X, Y - Edge);
|
|
DrawCornerTex(Edge, 0);
|
|
X += Edge;
|
|
return;
|
|
case ECS_HorisontalCorner:
|
|
Canvas.SetPos(X, Y);
|
|
DrawCornerTex(Edge, 3);
|
|
X += Edge;
|
|
return;
|
|
}
|
|
case ECP_BottomLeft:
|
|
switch (CornerShape)
|
|
{
|
|
case ECS_Corner:
|
|
return;
|
|
case ECS_BeveledCorner:
|
|
Canvas.SetPos(X, Y);
|
|
DrawCornerTex(Edge, 2);
|
|
X += Edge;
|
|
return;
|
|
case ECS_VerticalCorner:
|
|
Canvas.SetPos(X, Y);
|
|
DrawCornerTex(Edge, 3);
|
|
X += Edge;
|
|
return;
|
|
case ECS_HorisontalCorner:
|
|
Canvas.SetPos(X - Edge, Y);
|
|
DrawCornerTex(Edge, 0);
|
|
return;
|
|
}
|
|
case ECP_BottomRight:
|
|
switch (CornerShape)
|
|
{
|
|
case ECS_Corner:
|
|
return;
|
|
case ECS_BeveledCorner:
|
|
Canvas.SetPos(X, Y);
|
|
DrawCornerTex(Edge, 3);
|
|
X += Edge;
|
|
return;
|
|
case ECS_VerticalCorner:
|
|
Canvas.SetPos(X, Y); // X - Edge ?
|
|
DrawCornerTex(Edge, 2);
|
|
X += Edge;
|
|
return;
|
|
case ECS_HorisontalCorner:
|
|
Canvas.SetPos(X, Y);
|
|
DrawCornerTex(Edge, 1);
|
|
X += Edge;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
final function FillSmart(out float X, float Y, float W, float H, int Edge, int LeftShape, int RightShape)
|
|
{
|
|
if (LeftShape != ECS_HorisontalCorner && LeftShape != ECS_Corner)
|
|
{
|
|
W -= Edge;
|
|
}
|
|
|
|
if (RightShape != ECS_HorisontalCorner && RightShape != ECS_Corner)
|
|
{
|
|
W -= Edge;
|
|
}
|
|
|
|
if (LeftShape != ECS_VerticalCorner)
|
|
{
|
|
Canvas.SetPos(X, Y);
|
|
DrawWhiteBox(W, H);
|
|
}
|
|
|
|
X += W;
|
|
}
|
|
|
|
final function DrawRectBoxSmart(float X, float Y, float W, float H, int Edge, int TopLeftShape, int TopRightShape, int BottomLeftShape, int BottomRightShape)
|
|
{
|
|
local float TopY, MidY, BottomY, XPos;
|
|
local int FillCount;
|
|
local float MidRectHeight;
|
|
|
|
FillCount = 0;
|
|
|
|
if (TopLeftShape != ECS_VerticalCorner)
|
|
FillCount++;
|
|
if (BottomLeftShape != ECS_VerticalCorner)
|
|
FillCount++;
|
|
MidRectHeight = H - Edge * FillCount;
|
|
|
|
TopY = Y; MidY = TopY + (TopLeftShape == ECS_VerticalCorner ? 0 : Edge); BottomY = MidY + MidRectHeight;
|
|
|
|
// Top Line
|
|
XPos = X;
|
|
DrawCornerSmart(XPos, TopY, Edge, ECP_TopLeft, TopLeftShape);
|
|
FillSmart(XPos, TopY, W, Edge, Edge, TopLeftShape, TopRightShape);
|
|
DrawCornerSmart(XPos, TopY, Edge, ECP_TopRight, TopRightShape);
|
|
|
|
// Mid Line
|
|
XPos = X;
|
|
FillSmart(XPos, MidY, W, MidRectHeight, Edge, ECS_Corner, ECS_Corner);
|
|
|
|
// Bottom Line
|
|
XPos = X;
|
|
DrawCornerSmart(XPos, BottomY, Edge, ECP_BottomLeft, BottomLeftShape);
|
|
FillSmart(XPos, BottomY, W, Edge, Edge, BottomLeftShape, BottomRightShape);
|
|
DrawCornerSmart(XPos, BottomY, Edge, ECP_BottomRight, BottomRightShape);
|
|
}
|
|
|
|
final function DrawRectBox(float X, float Y, float Width, float Height, int Edge, optional byte Extrav)
|
|
{
|
|
if (Extrav == 2)
|
|
Edge=Min(FMin(Edge, (Width)*0.5), Height);// Verify size.
|
|
else
|
|
Edge=Min(FMin(Edge, (Width)*0.5), (Height)*0.5);// Verify size.
|
|
|
|
Canvas.PreOptimizeDrawTiles(Extrav == 0 ? 7 : 6, ItemTex);
|
|
|
|
switch (Extrav)
|
|
{
|
|
case 1:
|
|
// _______
|
|
// / /
|
|
// | |
|
|
// \______\
|
|
|
|
DrawRectBoxSmart(X, Y, Width, Height, Edge,
|
|
ECS_BeveledCorner, // TopLeft
|
|
ECS_HorisontalCorner, // TopRight
|
|
ECS_BeveledCorner, // BottomLeft
|
|
ECS_HorisontalCorner // BottomRight
|
|
);
|
|
break;
|
|
|
|
case 2:
|
|
// ______
|
|
// / \
|
|
// | ____ |
|
|
// |/ \|
|
|
|
|
DrawRectBoxSmart(X, Y, Width, Height, Edge,
|
|
ECS_BeveledCorner, // TopLeft
|
|
ECS_BeveledCorner, // TopRight
|
|
ECS_VerticalCorner, // BottomLeft
|
|
ECS_VerticalCorner // BottomRight
|
|
);
|
|
break;
|
|
|
|
case 3:
|
|
// _______
|
|
// \ \
|
|
// | |
|
|
// /______/
|
|
|
|
DrawRectBoxSmart(X, Y, Width, Height, Edge,
|
|
ECS_HorisontalCorner, // TopLeft
|
|
ECS_BeveledCorner, // TopRight
|
|
ECS_HorisontalCorner, // BottomLeft
|
|
ECS_BeveledCorner // BottomRight
|
|
);
|
|
break;
|
|
|
|
case 4:
|
|
//
|
|
// |\____/|
|
|
// | |
|
|
// \______/
|
|
|
|
DrawRectBoxSmart(X, Y, Width, Height, Edge,
|
|
ECS_VerticalCorner, // TopLeft
|
|
ECS_VerticalCorner, // TopRight
|
|
ECS_BeveledCorner, // BottomLeft
|
|
ECS_BeveledCorner // BottomRight
|
|
);
|
|
break;
|
|
|
|
case 5:
|
|
// ______
|
|
// | |
|
|
// | |
|
|
// |______|
|
|
|
|
DrawRectBoxSmart(X, Y, Width, Height, Edge,
|
|
ECS_Corner, // TopLeft
|
|
ECS_Corner, // TopRight
|
|
ECS_Corner, // BottomLeft
|
|
ECS_Corner // BottomRight
|
|
);
|
|
default: // 0
|
|
// ______
|
|
// / \
|
|
// | |
|
|
// \______/
|
|
|
|
DrawRectBoxSmart(X, Y, Width, Height, Edge,
|
|
ECS_BeveledCorner, // TopLeft
|
|
ECS_BeveledCorner, // TopRight
|
|
ECS_BeveledCorner, // BottomLeft
|
|
ECS_BeveledCorner // BottomRight
|
|
);
|
|
break;
|
|
}
|
|
}
|
|
|
|
final function DrawBoxHollow(float X, float Y, float Width, float Height, float Thickness)
|
|
{
|
|
Canvas.PreOptimizeDrawTiles(4, ItemTex);
|
|
|
|
Canvas.SetPos(X + Thickness, Y);
|
|
DrawWhiteBox(Width - Thickness * 2, Thickness);
|
|
|
|
Canvas.SetPos(X + Thickness, Y+Height-Thickness);
|
|
DrawWhiteBox(Width - Thickness * 2, Thickness);
|
|
|
|
Canvas.SetPos(X, Y);
|
|
DrawWhiteBox(Thickness, Height);
|
|
|
|
Canvas.SetPos(X + Width - Thickness, Y);
|
|
DrawWhiteBox(Thickness, Height);
|
|
}
|
|
|
|
final function DrawOutlinedBox(float X, float Y, float Width, float Height, float Thickness, Color BoxColor, Color OutlineColor)
|
|
{
|
|
Canvas.DrawColor = BoxColor;
|
|
Canvas.SetPos(X + Thickness, Y + Thickness);
|
|
DrawWhiteBox(Width - (Thickness*2), Height - (Thickness*2));
|
|
|
|
Canvas.DrawColor = OutlineColor;
|
|
DrawBoxHollow(X, Y, Width, Height, Thickness);
|
|
}
|
|
|
|
final function DrawBoxCorners(float BorderSize, float X, float Y, float W, float H, optional bool TopLeft, optional bool TopRight, optional bool BottomLeft, optional bool BottomRight)
|
|
{
|
|
// Top left
|
|
Canvas.SetPos(X, Y);
|
|
if (TopLeft)
|
|
DrawCornerTex(BorderSize, 0);
|
|
else DrawWhiteBox(BorderSize, BorderSize);
|
|
|
|
// Top right
|
|
Canvas.SetPos(X+W-BorderSize, Y);
|
|
if (TopRight)
|
|
DrawCornerTex(BorderSize, 1);
|
|
else DrawWhiteBox(BorderSize, BorderSize);
|
|
|
|
// Bottom left
|
|
Canvas.SetPos(X, Y+H-BorderSize);
|
|
if (BottomLeft)
|
|
DrawCornerTex(BorderSize, 2);
|
|
else DrawWhiteBox(BorderSize, BorderSize);
|
|
|
|
// Bottom right
|
|
Canvas.SetPos(X+W-BorderSize, Y+H-BorderSize);
|
|
if (BottomRight)
|
|
DrawCornerTex(BorderSize, 3);
|
|
else DrawWhiteBox(BorderSize, BorderSize);
|
|
}
|
|
|
|
final function DrawRoundedBox(float BorderSize, float X, float Y, float W, float H, Color BoxColor)
|
|
{
|
|
DrawRoundedBoxEx(BorderSize, X, Y, W, H, BoxColor, true, true, true, true);
|
|
}
|
|
|
|
final function DrawRoundedBoxEx(float BorderSize, float X, float Y, float W, float H, Color BoxColor, optional bool TopLeft, optional bool TopRight, optional bool BottomLeft, optional bool BottomRight)
|
|
{
|
|
Canvas.DrawColor = BoxColor;
|
|
|
|
if (BorderSize <= 0)
|
|
{
|
|
Canvas.SetPos(X, Y);
|
|
DrawWhiteBox(W, H);
|
|
return;
|
|
}
|
|
|
|
Canvas.PreOptimizeDrawTiles(7, ItemTex);
|
|
|
|
BorderSize = Min(FMin(BorderSize, (W)*0.5), (H)*0.5);
|
|
|
|
Canvas.SetPos(X + BorderSize, Y);
|
|
DrawWhiteBox(W - BorderSize * 2, H);
|
|
|
|
Canvas.SetPos(X, Y + BorderSize);
|
|
DrawWhiteBox(BorderSize, H - BorderSize * 2);
|
|
|
|
Canvas.SetPos(X + W - BorderSize, Y + BorderSize);
|
|
DrawWhiteBox(BorderSize, H - BorderSize * 2);
|
|
|
|
DrawBoxCorners(BorderSize, X, Y, W, H, TopLeft, TopRight, BottomLeft, BottomRight);
|
|
}
|
|
|
|
final function DrawRoundedBoxHollow(float BorderSize, float X, float Y, float W, float H, Color BoxColor)
|
|
{
|
|
DrawRoundedBoxHollowEx(BorderSize, X, Y, W, H, BoxColor, true, true, true, true);
|
|
}
|
|
|
|
final function DrawRoundedBoxHollowEx(float BorderSize, float X, float Y, float W, float H, Color BoxColor, optional bool TopLeft, optional bool TopRight, optional bool BottomLeft, optional bool BottomRight)
|
|
{
|
|
Canvas.PreOptimizeDrawTiles(8, ItemTex);
|
|
|
|
BorderSize = Min(FMin(BorderSize, (W)*0.5), (H)*0.5);
|
|
|
|
Canvas.DrawColor = BoxColor;
|
|
|
|
Canvas.SetPos(X + BorderSize, Y);
|
|
DrawWhiteBox(W - BorderSize * 2, BorderSize);
|
|
|
|
Canvas.SetPos(X + BorderSize, Y+H-BorderSize);
|
|
DrawWhiteBox(W - BorderSize * 2, BorderSize);
|
|
|
|
Canvas.SetPos(X, Y + BorderSize);
|
|
DrawWhiteBox(BorderSize, H - BorderSize * 2);
|
|
|
|
Canvas.SetPos(X + W - BorderSize, Y + BorderSize);
|
|
DrawWhiteBox(BorderSize, H - BorderSize * 2);
|
|
|
|
DrawBoxCorners(BorderSize, X, Y, W, H, TopLeft, TopRight, BottomLeft, BottomRight);
|
|
}
|
|
|
|
final function DrawRoundedBoxOutlined(float BorderSize, float X, float Y, float Width, float Height, Color BoxColor, Color OutlineColor)
|
|
{
|
|
Canvas.DrawColor = BoxColor;
|
|
Canvas.SetPos(X + BorderSize, Y + BorderSize);
|
|
DrawWhiteBox(Width - (BorderSize*2), Height - (BorderSize*2));
|
|
|
|
DrawRoundedBoxHollow(BorderSize, X, Y, Width, Height, OutlineColor);
|
|
}
|
|
|
|
final function DrawRoundedBoxOutlinedEx(float BorderSize, float X, float Y, float Width, float Height, Color BoxColor, Color OutlineColor, optional bool TopLeft, optional bool TopRight, optional bool BottomLeft, optional bool BottomRight)
|
|
{
|
|
Canvas.DrawColor = BoxColor;
|
|
Canvas.SetPos(X + BorderSize, Y + BorderSize);
|
|
DrawWhiteBox(Width - (BorderSize*2), Height - (BorderSize*2));
|
|
|
|
DrawRoundedBoxHollowEx(BorderSize, X, Y, Width, Height, OutlineColor, TopLeft, TopRight, BottomLeft, BottomRight);
|
|
}
|
|
|
|
final function DrawArrowBox(int Direction, float X, float Y, float Width, float Height)
|
|
{
|
|
local Texture2D DirectionMat;
|
|
|
|
switch (Direction)
|
|
{
|
|
case 0:
|
|
DirectionMat=ArrowTextures[`ARROW_UP];
|
|
break;
|
|
case 1:
|
|
DirectionMat=ArrowTextures[`ARROW_RIGHT];
|
|
break;
|
|
case 2:
|
|
DirectionMat=ArrowTextures[`ARROW_DOWN];
|
|
break;
|
|
case 3:
|
|
DirectionMat=ArrowTextures[`ARROW_LEFT];
|
|
break;
|
|
default:
|
|
DirectionMat=ArrowTextures[`ARROW_UP];
|
|
break;
|
|
}
|
|
|
|
DrawTileStretched(ScrollTexture, X,Y, Width, Height);
|
|
DrawTileStretched(DirectionMat, X,Y, Width, Height);
|
|
}
|
|
|
|
final function DrawTileStretched(Texture Tex, float X, float Y, float XS, float YS)
|
|
{
|
|
local float mW, mH, MidX, MidY, SmallTileW, SmallTileH, fX, fY;
|
|
local int OptimizeTiles;
|
|
|
|
if (Tex == None ) Tex = Texture2D'EngineMaterials.DefaultDiffuse';
|
|
|
|
// Get the size of the image
|
|
mW = Tex.GetSurfaceWidth();
|
|
mH = Tex.GetSurfaceHeight();
|
|
|
|
// Get the midpoints of the image
|
|
MidX = int(mW/2);
|
|
MidY = int(mH/2);
|
|
|
|
// Grab info about the scaled image
|
|
SmallTileW = XS - mW;
|
|
SmallTileH = YS - mH;
|
|
|
|
// Optimized
|
|
OptimizeTiles = 4;
|
|
|
|
if (mW < XS)
|
|
OptimizeTiles += 2;
|
|
if (mH < YS)
|
|
OptimizeTiles += 2;
|
|
if ((mH < YS) && (mW < XS))
|
|
OptimizeTiles += 1;
|
|
|
|
Canvas.PreOptimizeDrawTiles(OptimizeTiles, Tex);
|
|
|
|
// Draw the spans first
|
|
// Top and Bottom
|
|
if (mW < XS)
|
|
{
|
|
fX = MidX;
|
|
|
|
if (mH > YS)
|
|
fY = YS/2;
|
|
else
|
|
fY = MidY;
|
|
|
|
Canvas.SetPos(X+fX, Y);
|
|
Canvas.DrawTile(Tex, SmallTileW, fY, MidX, 0,1, fY);
|
|
Canvas.SetPos(X+fX, Y+YS-fY);
|
|
Canvas.DrawTile(Tex, SmallTileW, fY, MidX, mH-fY, 1,fY);
|
|
}
|
|
else
|
|
fX = XS / 2;
|
|
|
|
// Left and Right
|
|
if (mH < YS)
|
|
{
|
|
fY = MidY;
|
|
|
|
Canvas.SetPos(X, Y+fY);
|
|
Canvas.DrawTile(Tex, fX, SmallTileH, 0,fY, fX, 1);
|
|
Canvas.SetPos(X+XS-fX, Y+fY);
|
|
Canvas.DrawTile(Tex, fX, SmallTileH, mW-fX, fY, fX, 1);
|
|
}
|
|
else
|
|
fY = YS / 2;
|
|
|
|
// Center
|
|
if ((mH < YS) && (mW < XS))
|
|
{
|
|
Canvas.SetPos(X+fX, Y+fY);
|
|
Canvas.DrawTile(Tex, SmallTileW, SmallTileH, fX, fY, 1,1);
|
|
}
|
|
|
|
// Draw the 4 corners.
|
|
Canvas.SetPos(X, Y);
|
|
Canvas.DrawTile(Tex, fX, fY, 0,0, fX, fY);
|
|
Canvas.SetPos(X+XS-fX, Y);
|
|
Canvas.DrawTile(Tex, fX, fY, mW-fX, 0,fX, fY);
|
|
Canvas.SetPos(X, Y+YS-fY);
|
|
Canvas.DrawTile(Tex, fX, fY, 0,mH-fY, fX, fY);
|
|
Canvas.SetPos(X+XS-fX, Y+YS-fY);
|
|
Canvas.DrawTile(Tex, fX, fY, mW-fX, mH-fY, fX, fY);
|
|
}
|
|
|
|
final function DrawTextJustified(byte Justification, float X1, float Y1, float X2, float Y2, coerce string S, optional float XS, optional float YS)
|
|
{
|
|
local float XL, YL;
|
|
local float CurY, CurX;
|
|
|
|
Canvas.TextSize(S, XL, YL, XS, YS);
|
|
|
|
CurY = ((Y2-Y1) / 2) - (YL/2);
|
|
|
|
if (Justification == 0)
|
|
{
|
|
CurX = 0;
|
|
}
|
|
else if (Justification == 1)
|
|
{
|
|
if (XL > X2-X1)
|
|
CurX = 0;
|
|
else CurX = ((X2-X1) / 2) - (XL/2);
|
|
}
|
|
else if (Justification == 2)
|
|
{
|
|
CurX = (X2-X1) - XL;
|
|
}
|
|
|
|
Canvas.SetPos(CurX, CurY);
|
|
Canvas.DrawText(S, ,XS, YS);
|
|
}
|
|
|
|
static final function float TimeFraction(float Start, float End, float Current)
|
|
{
|
|
return FClamp((Current - Start) / (End - Start), 0.f, 1.f);
|
|
}
|
|
|
|
static final function string LTrim(coerce string S)
|
|
{
|
|
while (Left(S, 1) == " ")
|
|
S = Right(S, Len(S) - 1);
|
|
return S;
|
|
}
|
|
|
|
static final function string RTrim(coerce string S)
|
|
{
|
|
while (Right(S, 1) == " ")
|
|
S = Left(S, Len(S) - 1);
|
|
return S;
|
|
}
|
|
|
|
static final function string Trim(coerce string S)
|
|
{
|
|
return LTrim(RTrim(S));
|
|
}
|
|
|
|
defaultproperties
|
|
{
|
|
// Font'UI_Canvas_Fonts.Font_Main'
|
|
//MainFont=Font'KFScoreboardExt_Assets.Font.KFMainFont'
|
|
//InfiniteFont=Font'KFScoreboardExt_Assets.Font.KFInfiniteFont'
|
|
|
|
MainFont=Font'UI_Canvas_Fonts.Font_Main'
|
|
NumberFont=Font'UI_Canvas_Fonts.Font_General'
|
|
InfiniteFont=Font'UI_Canvas_Fonts.Font_Main'
|
|
}
|