280 lines
7.0 KiB
C++
280 lines
7.0 KiB
C++
#pragma once
|
|
#include <stdint.h>
|
|
#include <string>
|
|
|
|
namespace TLAC::Components
|
|
{
|
|
#pragma pack(push, 1)
|
|
struct Point
|
|
{
|
|
float x;
|
|
float y;
|
|
};
|
|
|
|
struct RawFont
|
|
{
|
|
uint32_t sprId; // ?
|
|
uint8_t width1; // glyph?
|
|
uint8_t height1; // glyph?
|
|
uint8_t width2; // advance?
|
|
uint8_t height2; // advance?
|
|
uint8_t metric08; // or flag?
|
|
uint8_t metric09; // or flag?
|
|
uint8_t padding0a[0x06];
|
|
float metric08divby09;
|
|
uint64_t _0x10;
|
|
int64_t dataBegin;
|
|
int64_t dataEnd;
|
|
int64_t dataCapacityEnd;
|
|
uint8_t padding38[0x8];
|
|
};
|
|
|
|
struct RawFontHolderIdk // ...SeemsPrettyPointlessTbh
|
|
{
|
|
RawFont* rawfont;
|
|
uint16_t width1;
|
|
uint16_t height1;
|
|
uint16_t zero1; // ?
|
|
uint16_t zero2; // ?
|
|
uint8_t zero3; // some kind of flag, but seems unused
|
|
};
|
|
|
|
struct FontInfo
|
|
{
|
|
uint32_t fontId;
|
|
uint8_t padding04[0x4];
|
|
RawFont* rawfont;
|
|
uint16_t flag10; // (zero3 != 0 && padding38[0] != 0) ? 2 : (metric08 != metric09 ? 1 : 0)
|
|
uint8_t padding12[0x02];
|
|
float width1;
|
|
float height1;
|
|
float width2;
|
|
float height2;
|
|
float userSizeWidth;
|
|
float userSizeHeight;
|
|
float userSizeWidthMultiplier; // userSizeWidth / width1
|
|
float userSizeHeightMultiplier; // userSizeHeight / width2
|
|
float zero1; // ?
|
|
float zero2; // ?
|
|
|
|
void setSize(float width, float height)
|
|
{
|
|
((void(*)(FontInfo* fi, float width, float height))0x140199e60)(this, width, height);
|
|
}
|
|
|
|
FontInfo(uint32_t id)
|
|
{
|
|
((FontInfo*(*)(FontInfo* fi, uint32_t id))0x140196510)(this, id);
|
|
}
|
|
};
|
|
|
|
FontInfo*(*getFont)(FontInfo* fi, uint32_t id) = (FontInfo*(*)(FontInfo* fi, uint32_t id))0x140196510;
|
|
void(*fontSize)(FontInfo* fi, float width, float height) = (void(*)(FontInfo* fi, float width, float height))0x140199e60;
|
|
|
|
struct DrawParams
|
|
{
|
|
uint32_t colour; // RGBA byte array?, so set as 0xAABBGGRR
|
|
uint32_t fillColour; // ?? RGBA byte array?, so set as 0xAABBGGRR
|
|
uint8_t unk08;
|
|
uint8_t unk09[0x3];
|
|
uint32_t unk0c;
|
|
uint32_t unk10;
|
|
uint32_t unk14;
|
|
uint32_t unk18;
|
|
uint32_t layer; // 8 seems similar to default but higher
|
|
// 0x19 is startup screen
|
|
// I noticed some use different scaling
|
|
uint32_t unk20;
|
|
uint32_t unk24;
|
|
uint32_t unk28;
|
|
Point originLoc;
|
|
Point currentLoc;
|
|
uint8_t padding3c[0x4];
|
|
uint64_t unk40;
|
|
FontInfo* font;
|
|
uint16_t unk50;
|
|
|
|
DrawParams(FontInfo* fi)
|
|
{
|
|
colour = 0xffffffff;
|
|
fillColour = 0xff808080; // except it's not?
|
|
unk08 = 0;
|
|
unk0c = 0;
|
|
unk10 = 0;
|
|
unk14 = 0;
|
|
unk18 = 0;
|
|
layer = 0x7;
|
|
unk20 = 0x0;
|
|
unk24 = 0xd;
|
|
unk28 = 0;
|
|
originLoc = { 0, 0 };
|
|
currentLoc = { 0, 0 };
|
|
unk40 = 0;
|
|
font = fi;
|
|
unk50 = 0x25a1;
|
|
}
|
|
|
|
DrawParams()
|
|
{
|
|
DrawParams((FontInfo*)0x140eda860);
|
|
}
|
|
};
|
|
|
|
/* struct MsString {
|
|
union {
|
|
char* string_ptr;
|
|
char string_buf[16];
|
|
};
|
|
uint64_t len;
|
|
uint64_t bufsize;
|
|
|
|
char* GetCharBuf()
|
|
{
|
|
if (bufsize > 0xf && string_ptr != nullptr)
|
|
return string_ptr;
|
|
else
|
|
return string_buf;
|
|
};
|
|
|
|
void SetCharBuf(char* newcontent)
|
|
{
|
|
len = strlen(newcontent);
|
|
bufsize = len;
|
|
if (len > 0xf)
|
|
{
|
|
string_ptr = strdup(newcontent);
|
|
}
|
|
else
|
|
{
|
|
strcpy_s(string_buf, newcontent);
|
|
}
|
|
}
|
|
}; */
|
|
|
|
/* struct MsStringW {
|
|
union {
|
|
wchar_t* string_ptr;
|
|
wchar_t string_buf[8];
|
|
};
|
|
uint64_t len;
|
|
uint64_t bufsize;
|
|
|
|
wchar_t* GetCharBuf()
|
|
{
|
|
if (bufsize > 0x7 && string_ptr != nullptr)
|
|
return string_ptr;
|
|
else
|
|
return string_buf;
|
|
};
|
|
|
|
void SetCharBuf(wchar_t* newcontent)
|
|
{
|
|
len = wcslen(newcontent);
|
|
bufsize = len;
|
|
if (len > 0xf)
|
|
{
|
|
string_ptr = wcsdup(newcontent);
|
|
}
|
|
else
|
|
{
|
|
wcscpy_s(string_buf, newcontent);
|
|
}
|
|
}
|
|
}; */
|
|
|
|
enum drawTextFlags : uint32_t
|
|
{
|
|
DRAWTEXT_ENABLE_LAYOUT = 1, //?
|
|
DRAWTEXT_ALIGN_RIGHT = 2,
|
|
DRAWTEXT_ALIGN_CENTRE = 8,
|
|
DRAWTEXT_STROKE = 0x10000,
|
|
};
|
|
|
|
void drawText(DrawParams* dtParam, drawTextFlags flags, std::string str)
|
|
{
|
|
((void(*)(DrawParams*, uint32_t, const char*, int64_t))0x140198500)(dtParam, flags, str.c_str(), str.length());
|
|
}
|
|
|
|
void drawTextW(DrawParams* dtParam, drawTextFlags flags, std::wstring str)
|
|
{
|
|
const wchar_t* ptrs[2];
|
|
ptrs[0] = str.c_str();
|
|
ptrs[1] = (wchar_t*)((uint64_t)ptrs[0] + str.length() * 2);
|
|
|
|
((void(*)(DrawParams*, uint32_t, const wchar_t**))0x140198380)(dtParam, flags, &ptrs[0]);
|
|
}
|
|
//void(*drawTextW)(DrawParams* dtParam, drawTextFlags flags, MsStringW str) = (void(*)(DrawParams* dtParam, drawTextFlags flags, MsStringW str))0x140198380;
|
|
|
|
struct RectangleBounds
|
|
{
|
|
float x;
|
|
float y;
|
|
float width;
|
|
float height;
|
|
};
|
|
void(*fillRectangle)(DrawParams* dtParam, RectangleBounds* rect) = (void(*)(DrawParams* dtParam, RectangleBounds* rect))0x140198d80;
|
|
|
|
// draws only a border -- use fillRectangle to fill contained pixels
|
|
void drawRectangle(DrawParams* dtParam, RectangleBounds* rect)
|
|
{
|
|
((void(*)(DrawParams*, RectangleBounds*))0x140198320)(dtParam, rect);
|
|
}
|
|
|
|
// draws only a border -- use fillRectangle to fill contained pixels
|
|
void drawRectangle(DrawParams* dtParam, RectangleBounds* rect, float thickness)
|
|
{
|
|
uint32_t oldFillColour = dtParam->fillColour;
|
|
dtParam->fillColour = dtParam->colour;
|
|
|
|
// yes this seems pretty dodgy, but sega does it this way so... I guess it's the only way
|
|
RectangleBounds tempRect = { rect->x, rect->y, thickness, rect->height }; // left side
|
|
fillRectangle(dtParam, &tempRect);
|
|
|
|
tempRect.x = rect->x + rect->width - thickness; // right side
|
|
fillRectangle(dtParam, &tempRect);
|
|
|
|
tempRect = { rect->x + thickness, rect->y, rect->width - (thickness * 2), thickness }; // top side
|
|
fillRectangle(dtParam, &tempRect);
|
|
|
|
tempRect.y = rect->y + rect->height - thickness; // left side
|
|
fillRectangle(dtParam, &tempRect);
|
|
|
|
dtParam->fillColour = oldFillColour;
|
|
}
|
|
|
|
enum createAetFlags : uint32_t
|
|
{
|
|
CREATEAET_20000 = 0x20000,
|
|
};
|
|
|
|
// draw an aet layer (with all settings)
|
|
int createAetLayer(int32_t unk1, uint32_t drawLayer, createAetFlags flags, char* name, Point* loc, int32_t unk2, char* animation, char* animation2, float animationInTime, float animationOutTime, Point* scale, int32_t unk5)
|
|
{
|
|
return ((int(*)(int32_t, uint32_t, createAetFlags, char*, Point*, int32_t, char*, char*, float, float, Point*, int32_t))0x14013be60)(unk1, drawLayer, flags, name, loc, unk2, animation, animation2, animationInTime, animationOutTime, scale, unk5);
|
|
}
|
|
// draw an aet layer (with animation timing override)
|
|
int createAetLayer(uint32_t drawLayer, createAetFlags flags, char* name, Point* loc, float animationInTime, float animationOutTime)
|
|
{
|
|
return createAetLayer(3, drawLayer, flags, name, loc, 0, 0, 0, animationInTime, animationOutTime, 0, 0);
|
|
}
|
|
// draw an aet layer (with scale)
|
|
int createAetLayer(uint32_t drawLayer, createAetFlags flags, char* name, Point* loc, Point* scale)
|
|
{
|
|
return createAetLayer(3, drawLayer, flags, name, loc, 0, 0, 0, -1, -1, scale, 0);
|
|
}
|
|
// draw an aet layer
|
|
int createAetLayer(uint32_t drawLayer, createAetFlags flags, char* name, Point* loc)
|
|
{
|
|
return createAetLayer(3, drawLayer, flags, name, loc, 0, 0, 0, -1, -1, 0, 0);
|
|
}
|
|
|
|
void destroyAetLayer(int &layer)
|
|
{
|
|
if (layer != 0)
|
|
{
|
|
((void(*)(int layer))0x14019d570)(layer);
|
|
layer = 0;
|
|
}
|
|
}
|
|
#pragma pack(pop)
|
|
} |