mirror of
https://github.com/hrydgard/ppsspp.git
synced 2024-12-18 02:48:28 +00:00
377 lines
9.9 KiB
C++
377 lines
9.9 KiB
C++
#include "sceFont.h"
|
|
|
|
#include "base/timeutil.h"
|
|
|
|
#include "HLE.h"
|
|
#include "../MIPS/MIPS.h"
|
|
|
|
#include "sceFont.h"
|
|
|
|
|
|
typedef u32 FontLibraryHandle;
|
|
typedef u32 FontHandle;
|
|
|
|
typedef struct {
|
|
u32* userDataAddr;
|
|
u32 numFonts;
|
|
u32* cacheDataAddr;
|
|
|
|
// Driver callbacks.
|
|
void *(*allocFuncAddr)(void *, u32);
|
|
void (*freeFuncAddr )(void *, void *);
|
|
u32* openFuncAddr;
|
|
u32* closeFuncAddr;
|
|
u32* readFuncAddr;
|
|
u32* seekFuncAddr;
|
|
u32* errorFuncAddr;
|
|
u32* ioFinishFuncAddr;
|
|
} FontNewLibParams;
|
|
|
|
typedef enum {
|
|
FONT_FAMILY_SANS_SERIF = 1,
|
|
FONT_FAMILY_SERIF = 2,
|
|
} Family;
|
|
|
|
typedef enum {
|
|
FONT_STYLE_REGULAR = 1,
|
|
FONT_STYLE_ITALIC = 2,
|
|
FONT_STYLE_BOLD = 5,
|
|
FONT_STYLE_BOLD_ITALIC = 6,
|
|
FONT_STYLE_DB = 103, // Demi-Bold / semi-bold
|
|
} Style;
|
|
|
|
typedef enum {
|
|
FONT_LANGUAGE_JAPANESE = 1,
|
|
FONT_LANGUAGE_LATIN = 2,
|
|
FONT_LANGUAGE_KOREAN = 3,
|
|
} Language;
|
|
|
|
typedef struct {
|
|
float fontH;
|
|
float fontV;
|
|
float fontHRes;
|
|
float fontVRes;
|
|
float fontWeight;
|
|
u16 fontFamily;
|
|
u16 fontStyle;
|
|
// Check.
|
|
u16 fontStyleSub;
|
|
u16 fontLanguage;
|
|
u16 fontRegion;
|
|
u16 fontCountry;
|
|
char fontName[64];
|
|
char fontFileName[64];
|
|
u32 fontAttributes;
|
|
u32 fontExpire;
|
|
} FontStyle;
|
|
|
|
typedef struct {
|
|
// Glyph metrics (in 26.6 signed fixed-point).
|
|
u32 maxGlyphWidthI;
|
|
u32 maxGlyphHeightI;
|
|
u32 maxGlyphAscenderI;
|
|
u32 maxGlyphDescenderI;
|
|
u32 maxGlyphLeftXI;
|
|
u32 maxGlyphBaseYI;
|
|
u32 minGlyphCenterXI;
|
|
u32 maxGlyphTopYI;
|
|
u32 maxGlyphAdvanceXI;
|
|
u32 maxGlyphAdvanceYI;
|
|
|
|
// Glyph metrics (replicated as float).
|
|
float maxGlyphWidthF;
|
|
float maxGlyphHeightF;
|
|
float maxGlyphAscenderF;
|
|
float maxGlyphDescenderF;
|
|
float maxGlyphLeftXF;
|
|
float maxGlyphBaseYF;
|
|
float minGlyphCenterXF;
|
|
float maxGlyphTopYF;
|
|
float maxGlyphAdvanceXF;
|
|
float maxGlyphAdvanceYF;
|
|
|
|
// Bitmap dimensions.
|
|
short maxGlyphWidth;
|
|
short maxGlyphHeight;
|
|
u32 charMapLength; // Number of elements in the font's charmap.
|
|
u32 shadowMapLength; // Number of elements in the font's shadow charmap.
|
|
|
|
// Font style (used by font comparison functions).
|
|
FontStyle fontStyle;
|
|
|
|
u8 BPP; // Font's BPP.
|
|
u8 pad[3];
|
|
} FontInfo;
|
|
|
|
typedef struct {
|
|
u32 bitmapWidth;
|
|
u32 bitmapHeight;
|
|
u32 bitmapLeft;
|
|
u32 bitmapTop;
|
|
// Glyph metrics (in 26.6 signed fixed-point).
|
|
u32 spf26Width;
|
|
u32 spf26Height;
|
|
s32 spf26Ascender;
|
|
s32 spf26Descender;
|
|
s32 spf26BearingHX;
|
|
s32 spf26BearingHY;
|
|
s32 spf26BearingVX;
|
|
s32 spf26BearingVY;
|
|
s32 spf26AdvanceH;
|
|
s32 spf26AdvanceV;
|
|
u8 pad[4];
|
|
} CharInfo;
|
|
|
|
typedef enum {
|
|
PSP_FONT_PIXELFORMAT_4 = 0,
|
|
PSP_FONT_PIXELFORMAT_4_REV = 1,
|
|
PSP_FONT_PIXELFORMAT_8 = 2,
|
|
PSP_FONT_PIXELFORMAT_24 = 3,
|
|
PSP_FONT_PIXELFORMAT_32 = 4
|
|
} FontPixelFormat;
|
|
|
|
typedef struct {
|
|
FontPixelFormat pixelFormat;
|
|
s32 xPos64;
|
|
s32 yPos64;
|
|
u16 bufWidth;
|
|
u16 bufHeight;
|
|
u16 bytesPerLine;
|
|
u16 pad;
|
|
void *buffer;
|
|
} GlyphImage;
|
|
|
|
FontNewLibParams fontLib;
|
|
|
|
u32 sceFontNewLib(u32 FontNewLibParamsPtr, u32 errorCodePtr)
|
|
{
|
|
ERROR_LOG(HLE, "sceFontNewLib %x, %x", FontNewLibParamsPtr, errorCodePtr);
|
|
|
|
if (Memory::IsValidAddress(FontNewLibParamsPtr)&&Memory::IsValidAddress(errorCodePtr))
|
|
{
|
|
Memory::Write_U32(0, errorCodePtr);
|
|
Memory::ReadStruct(FontNewLibParamsPtr, &fontLib);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
int sceFontDoneLib(u32 FontLibraryHandlePtr)
|
|
{
|
|
ERROR_LOG(HLE, "sceFontDoneLib %x", FontLibraryHandlePtr);
|
|
return 0;
|
|
}
|
|
|
|
|
|
u32 sceFontOpen(u32 libHandle, u32 index, u32 mode, u32 errorCodePtr)
|
|
{
|
|
ERROR_LOG(HLE, "sceFontDoneLib %x, %x, %x, %x", libHandle, index, mode, errorCodePtr);
|
|
if (Memory::IsValidAddress(errorCodePtr))
|
|
{
|
|
Memory::Write_U32(0, errorCodePtr);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
u32 sceFontOpenUserMemory(u32 libHandle, u32 memoryFontAddrPtr, u32 memoryFontLength, u32 errorCodePtr)
|
|
{
|
|
ERROR_LOG(HLE, "sceFontOpenUserMemory %x, %x, %x, %x", libHandle, memoryFontAddrPtr, memoryFontLength, errorCodePtr);
|
|
if (Memory::IsValidAddress(errorCodePtr))
|
|
{
|
|
Memory::Write_U32(0, errorCodePtr);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
u32 sceFontOpenUserFile(u32 libHandle, u32 fileNamePtr, u32 mode, u32 errorCodePtr)
|
|
{
|
|
ERROR_LOG(HLE, "sceFontOpenUserFile %x, %x, %x, %x", libHandle, fileNamePtr, mode, errorCodePtr);
|
|
if (Memory::IsValidAddress(errorCodePtr))
|
|
{
|
|
Memory::Write_U32(0, errorCodePtr);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int sceFontClose(u32 fontHandle)
|
|
{
|
|
ERROR_LOG(HLE, "sceFontClose %x", fontHandle);
|
|
return 0;
|
|
}
|
|
|
|
|
|
int sceFontGetNumFontList(u32 libHandle, u32 errorCodePtr)
|
|
{
|
|
ERROR_LOG(HLE, "sceFontGetNumFontList %x, %x", libHandle, errorCodePtr);
|
|
if (Memory::IsValidAddress(errorCodePtr))
|
|
{
|
|
Memory::Write_U32(0, errorCodePtr);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int sceFontFindOptimumFont(u32 libHandlePtr, u32 fontStylePtr, u32 errorCodePtr)
|
|
{
|
|
ERROR_LOG(HLE, "sceFontFindOptimumFont %x, %x, %x", libHandlePtr, fontStylePtr, errorCodePtr);
|
|
if (Memory::IsValidAddress(errorCodePtr))
|
|
{
|
|
Memory::Write_U32(0, errorCodePtr);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int sceFontFindFont(u32 libHandlePtr, u32 fontStylePtr, u32 errorCodePtr)
|
|
{
|
|
ERROR_LOG(HLE, "sceFontFindFont %x, %x, %x", libHandlePtr, fontStylePtr, errorCodePtr);
|
|
return 1;
|
|
}
|
|
|
|
int sceFontGetFontInfo(u32 fontHandle, u32 fontInfoPtr)
|
|
{
|
|
ERROR_LOG(HLE, "sceFontGetFontInfo %x, %x", fontHandle, fontInfoPtr);
|
|
|
|
FontInfo fi;
|
|
memset (&fi, 0, sizeof(fi));
|
|
if (Memory::IsValidAddress(fontInfoPtr))
|
|
{
|
|
fi.BPP = 4;
|
|
fi.charMapLength = 255;
|
|
fi.maxGlyphAdvanceXF = 2.0;
|
|
fi.maxGlyphAdvanceXI = 2;
|
|
fi.maxGlyphAdvanceYF = 2.0;
|
|
fi.maxGlyphAdvanceYI = 32 << 6;
|
|
fi.maxGlyphAscenderF = 32 << 6;
|
|
fi.maxGlyphAscenderI = 32 << 6;
|
|
fi.maxGlyphBaseYF = 0.0;
|
|
fi.maxGlyphBaseYI = 0;
|
|
fi.maxGlyphDescenderF = 0;
|
|
fi.maxGlyphDescenderI = 0;
|
|
fi.maxGlyphHeight = 32;
|
|
fi.maxGlyphHeightF = 32;
|
|
fi.maxGlyphHeightI = 32;
|
|
fi.maxGlyphLeftXF = 0;
|
|
fi.maxGlyphLeftXI = 0;
|
|
fi.maxGlyphTopYF = 0;
|
|
fi.maxGlyphTopYI = 0;
|
|
fi.maxGlyphWidth = 32;
|
|
fi.maxGlyphWidthF = 32;
|
|
fi.maxGlyphWidthI = 32;
|
|
fi.minGlyphCenterXF = 16;
|
|
fi.minGlyphCenterXI = 16;
|
|
fi.shadowMapLength = 0;
|
|
Memory::WriteStruct(fontInfoPtr, &fi);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int sceFontGetFontInfoByIndexNumber(u32 libHandle, u32 fontInfoPtr, u32 unknown, u32 fontIndex)
|
|
{
|
|
ERROR_LOG(HLE, "sceFontGetFontInfoByIndexNumber %x, %x, %x, %x", libHandle, fontInfoPtr, unknown, fontIndex);
|
|
// clearly wrong..
|
|
return sceFontGetFontInfo(libHandle, fontInfoPtr);
|
|
|
|
}
|
|
|
|
int sceFontGetCharInfo(u32 libHandler, u32 charCode, u32 charInfoPtr)
|
|
{
|
|
ERROR_LOG(HLE, "sceFontGetCharInfo %x, %x, %x", libHandler, charCode, charInfoPtr);
|
|
if (Memory::IsValidAddress(charInfoPtr))
|
|
{
|
|
CharInfo pspCharInfo;
|
|
memset(&pspCharInfo, 0, sizeof(pspCharInfo));
|
|
pspCharInfo.bitmapWidth = 32;
|
|
pspCharInfo.bitmapHeight = 32;
|
|
|
|
pspCharInfo.spf26Width = pspCharInfo.bitmapWidth << 6;
|
|
pspCharInfo.spf26Height = pspCharInfo.bitmapHeight << 6;
|
|
pspCharInfo.spf26AdvanceH = pspCharInfo.bitmapWidth << 6;
|
|
pspCharInfo.spf26AdvanceV = pspCharInfo.bitmapHeight << 6;
|
|
Memory::WriteStruct(charInfoPtr, &pspCharInfo);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int sceFontGetCharGlyphImage(u32 libHandler, u32 charCode, u32 glyphImagePtr)
|
|
{
|
|
ERROR_LOG(HLE, "sceFontGetCharGlyphImage %x, %x, %x (%c)", libHandler, charCode, glyphImagePtr, charCode);
|
|
|
|
int pixelFormat = Memory::Read_U32(glyphImagePtr);
|
|
int xPos64 = Memory::Read_U32(glyphImagePtr+4);
|
|
int yPos64 = Memory::Read_U32(glyphImagePtr+8);
|
|
int bufWidth = Memory::Read_U16(glyphImagePtr+12);
|
|
int bufHeight = Memory::Read_U16(glyphImagePtr+14);
|
|
int bytesPerLine = Memory::Read_U16(glyphImagePtr+16);
|
|
int buffer =Memory::Read_U32(glyphImagePtr+20);
|
|
|
|
Memory::Memset(buffer, 0x7F, bytesPerLine*bufHeight*pixelFormat);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int sceFontGetCharGlyphImage_Clip(u32 libHandler, u32 charCode, u32 glyphImagePtr, int clipXPos, int clipYPos, int clipWidth, int clipHeight)
|
|
{
|
|
ERROR_LOG(HLE, "sceFontGetCharGlyphImage_Clip %x, %x, %x (%c)", libHandler, charCode, glyphImagePtr, charCode);
|
|
//sceFontGetCharGlyphImage(libHandler, charCode, glyphImagePtr);
|
|
return 0;
|
|
}
|
|
|
|
int sceFontGetFontList(u32 fontLibHandle, u32 fontStylePtr, u32 numFonts)
|
|
{
|
|
ERROR_LOG(HLE, "sceFontGetFontList %x, %x, %x", fontLibHandle, fontStylePtr, numFonts);
|
|
|
|
FontStyle style;
|
|
memset(&style, 0, sizeof (style));
|
|
|
|
style.fontH = 20 / 64.f;
|
|
style.fontV = 20 / 64.f;
|
|
style.fontHRes = 20 / 64.f;
|
|
style.fontVRes = 20 / 64.f;
|
|
style.fontStyle = 1;
|
|
|
|
for (u32 i = 0; i < numFonts; i++)
|
|
{
|
|
Memory::WriteStruct(fontStylePtr+ (sizeof(style)), &style);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
const HLEFunction sceLibFont[] =
|
|
{
|
|
{0x67f17ed7, WrapU_UU<sceFontNewLib>, "sceFontNewLib"},
|
|
{0x574b6fbc, WrapI_U<sceFontDoneLib>, "sceFontDoneLib"},
|
|
{0x48293280, 0, "sceFontSetResolution"},
|
|
{0x27f6e642, WrapI_UU<sceFontGetNumFontList>, "sceFontGetNumFontList"},
|
|
{0xbc75d85b, WrapI_UUU<sceFontGetFontList>, "sceFontGetFontList"},
|
|
{0x099ef33c, WrapI_UUU<sceFontFindOptimumFont>, "sceFontFindOptimumFont"},
|
|
{0x681e61a7, WrapI_UUU<sceFontFindFont>, "sceFontFindFont"},
|
|
{0x2f67356a, 0, "sceFontCalcMemorySize"},
|
|
{0x5333322d, WrapI_UUUU<sceFontGetFontInfoByIndexNumber>, "sceFontGetFontInfoByIndexNumber"},
|
|
{0xa834319d, WrapU_UUUU<sceFontOpen>, "sceFontOpen"},
|
|
{0x57fcb733, WrapU_UUUU<sceFontOpenUserFile>, "sceFontOpenUserFile"},
|
|
{0xbb8e7fe6, WrapU_UUUU<sceFontOpenUserMemory>, "sceFontOpenUserMemory"},
|
|
{0x3aea8cb6, WrapI_U<sceFontClose>, "sceFontClose"},
|
|
{0x0da7535e, WrapI_UU<sceFontGetFontInfo>, "sceFontGetFontInfo"},
|
|
{0xdcc80c2f, WrapI_UUU<sceFontGetCharInfo>, "sceFontGetCharInfo"},
|
|
{0x5c3e4a9e, 0, "sceFontGetCharImageRect"},
|
|
{0x980f4895, WrapI_UUU<sceFontGetCharGlyphImage>, "sceFontGetCharGlyphImage"},
|
|
{0xca1e6945, WrapI_UUUIIII<sceFontGetCharGlyphImage_Clip>, "sceFontGetCharGlyphImage_Clip"},
|
|
{0x74b21701, 0, "sceFontPixelToPointH"},
|
|
{0xf8f0752e, 0, "sceFontPixelToPointV"},
|
|
{0x472694cd, 0, "sceFontPointToPixelH"},
|
|
{0x3c4b7e82, 0, "sceFontPointToPixelV"},
|
|
{0xee232411, 0, "sceFontSetAltCharacterCode"},
|
|
{0xaa3de7b5, 0, "sceFontGetShadowInfo"},
|
|
{0x48b06520, 0, "sceFontGetShadowImageRect"},
|
|
{0x568be516, 0, "sceFontGetShadowGlyphImage"},
|
|
{0x5dcf6858, 0, "sceFontGetShadowGlyphImage_Clip"},
|
|
{0x02d7f94b, 0, "sceFontFlush"},
|
|
|
|
};
|
|
void Register_sceFont()
|
|
{
|
|
RegisterModule("sceLibFont", ARRAY_SIZE(sceLibFont), sceLibFont);
|
|
}
|
|
|