mirror/ac-decomp
1
0
Fork 0
mirror of https://github.com/ACreTeam/ac-decomp synced 2026-06-01 01:08:51 -04:00
Code Issues Packages Projects Releases Wiki Activity
Files
0f74b4c6e06de33d44bc29551c61ba33aa6aafff
ac-decomp/rel/m_font.c
T
Cuyler36 e8bb03784d m_notice work
2023-05-09 20:28:40 -04:00

1435 lines
36 KiB
C
Raw Blame History

#include "m_font.h"
#include "audio.h"
#include "m_lib.h"
#include "gbi_extensions.h"
#include "dataobject.h"
#include "game.h"
#include "graph.h"
#include "types.h"
#include "libultra/gu.h"
#include "sys_matrix.h"
#include "MSL_C/w_math.h"
#include "m_rcp.h"
#include "libc/math.h"
#define mFont_CC_FONT 0, 0, 0, PRIMITIVE, PRIMITIVE, 0, TEXEL0, 0
#define mFont_CC_NOFONT 0, 0, 0, PRIMITIVE, 0, PRIMITIVE, TEXEL0, PRIMITIVE
/* @unused static u8* mFont_Get_end_load_texture() */
extern void mFont_ct() {
// code removed probably
}
static int mMsg_CutLeftSpace(u8* str, int str_len) {
// This should've been renamed or moved to m_message.h
u8* dst;
u8* src;
int i, j;
for (i = 0; i < str_len; i++) {
if (str[i] != CHAR_SPACE) {
break;
}
}
if (i == str_len) {
return 0;
}
else if (i == 0) {
return str_len;
}
dst = str;
src = str + i;
for (j = i; j < str_len; j++) {
*dst++ = *src++;
}
for (j = 0; j < i; j++) {
*dst++ = CHAR_SPACE;
}
return str_len - i;
}
static u8 mFont_suji_data[] = "0123456789";
static int mFont_suji_check(u8 c) {
u8* suji = mFont_suji_data;
int i;
for (i = 0; i < 10; i++) {
if (c == suji[i]) {
return TRUE;
}
}
return FALSE;
}
extern int mFont_UnintToString(
u8* str,
int figure,
u32 num,
int figure_start,
int left_cut,
int fill_zero,
int separator
) {
int i;
int j;
u32 cur_num;
int next;
int temp2;
int last_figure;
int l = figure - figure_start;
u8 fill_char = fill_zero ? CHAR_ZERO : CHAR_SPACE;
u8 left_fill_char = fill_zero && !left_cut ? CHAR_ZERO : CHAR_SPACE;
cur_num = num;
for (last_figure = figure - 1; last_figure >= l; last_figure--) {
next = cur_num / 10;
temp2 = cur_num - next * 10;
if (cur_num == 0) {
if (num == 0 && last_figure == figure - 1) {
str[last_figure] = CHAR_ZERO;
}
else {
str[last_figure] = fill_char;
}
}
else {
str[last_figure] = mFont_suji_data[temp2];
}
cur_num = next;
}
for (i = last_figure; i >= 0; i--) {
str[i] = left_fill_char;
}
if (separator) {
int count = 0;
for (i = figure - 1; i >= 0; i--) {
if (mFont_suji_check(str[i])) {
count++;
if (count > 3) {
for (j = 0; j < i; j++) {
str[j] = str[j + 1];
}
str[i] = CHAR_COMMA;
count = 0;
}
}
}
}
if (left_cut) {
return mMsg_CutLeftSpace(str, figure);
}
return figure;
}
extern int mFont_char_save_data_check(u8 c) {
return c == CHAR_CONTROL_CODE || c == CHAR_MESSAGE_TAG;
}
// TODO: Match
extern u8 mFont_small_to_capital(u8 small) {
static const u8 tbl[56][2] = {
{ CHAR_a, CHAR_A },
{ CHAR_b, CHAR_B },
{ CHAR_c, CHAR_C },
{ CHAR_d, CHAR_D },
{ CHAR_e, CHAR_E },
{ CHAR_f, CHAR_F },
{ CHAR_g, CHAR_G },
{ CHAR_h, CHAR_H },
{ CHAR_i, CHAR_I },
{ CHAR_j, CHAR_J },
{ CHAR_k, CHAR_K },
{ CHAR_l, CHAR_L },
{ CHAR_m, CHAR_M },
{ CHAR_n, CHAR_N },
{ CHAR_o, CHAR_O },
{ CHAR_p, CHAR_P },
{ CHAR_q, CHAR_Q },
{ CHAR_r, CHAR_R },
{ CHAR_s, CHAR_S },
{ CHAR_t, CHAR_T },
{ CHAR_u, CHAR_U },
{ CHAR_v, CHAR_V },
{ CHAR_w, CHAR_W },
{ CHAR_x, CHAR_X },
{ CHAR_y, CHAR_Y },
{ CHAR_z, CHAR_Z },
{ CHAR_DIARESIS_a, CHAR_DIAERESIS_A },
{ CHAR_GRAVE_a, CHAR_GRAVE_A },
{ CHAR_ACUTE_a, CHAR_ACUTE_A },
{ CHAR_CIRCUMFLEX_a, CHAR_CIRCUMFLEX_A },
{ CHAR_TILDE_a, CHAR_TILDE_A },
{ CHAR_ANGSTROM_a, CHAR_ANGSTROM_A },
{ CHAR_LOWER_CEDILLA, CHAR_CEDILLA },
{ CHAR_GRAVE_e, CHAR_GRAVE_E },
{ CHAR_ACUTE_e, CHAR_ACUTE_E },
{ CHAR_CIRCUMFLEX_e, CHAR_CIRCUMFLEX_E },
{ CHAR_DIARESIS_e, CHAR_DIARESIS_E },
{ CHAR_GRAVE_i, CHAR_GRAVE_I },
{ CHAR_ACUTE_i, CHAR_ACUTE_I },
{ CHAR_CIRCUMFLEX_i, CHAR_CIRCUMFLEX_I },
{ CHAR_DIARESIS_i, CHAR_DIARESIS_I },
{ CHAR_LOWER_ETH, CHAR_ETH },
{ CHAR_TILDE_n, CHAR_TILDE_N },
{ CHAR_GRAVE_o, CHAR_GRAVE_O },
{ CHAR_ACUTE_o, CHAR_ACUTE_O },
{ CHAR_CIRCUMFLEX_o, CHAR_CIRCUMFLEX_O },
{ CHAR_TILDE_o, CHAR_TILDE_O },
{ CHAR_DIARESIS_o, CHAR_DIARESIS_O },
{ CHAR_oe, CHAR_OE },
{ CHAR_GRAVE_u, CHAR_GRAVE_U },
{ CHAR_ACUTE_u, CHAR_ACUTE_U },
{ CHAR_CIRCUMFLEX_u, CHAR_CIRCUMFLEX_U },
{ CHAR_DIARESIS_u, CHAR_DIARESIS_U },
{ CHAR_ACUTE_y, CHAR_ACUTE_Y },
{ CHAR_LOWER_THORN, CHAR_THORN },
{ CHAR_LOWER_ASH, CHAR_ASH }
};
int i;
for (i = 0; i < 56; i++) {
if (tbl[i][0] == small) {
return tbl[i][1];
}
}
return small;
}
static int mFont_Get_FontOffset(int c) {
static u8 offset_data[256] = {
6, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6,
6, 4, 4, 3, 3, 3, 3, 3, 3, 5, 5, 5, 5, 5, 5, 5,
7, 6, 5, 5, 5, 1, 4, 8, 6, 6, 1, 0, 8, 4, 8, 0,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 1, 4, 3, 4, 4,
2, 3, 5, 4, 4, 5, 5, 4, 4, 6, 6, 5, 5, 2, 4, 4,
5, 3, 5, 5, 5, 4, 4, 2, 5, 5, 6, 5, 0, 5, 5, 3,
5, 5, 5, 5, 5, 6, 7, 5, 4, 7, 7, 6, 7, 3, 5, 5,
5, 4, 6, 6, 7, 5, 6, 3, 6, 6, 7, 5, 5, 5, 5, 0,
0, 6, 6, 6, 6, 8, 4, 5, 5, 5, 5, 5, 5, 3, 5, 5,
0, 5, 5, 5, 5, 5, 5, 6, 6, 5, 5, 4, 5, 6, 6, 6,
3, 4, 2, 3, 5, 2, 2, 0, 0, 0, 0, 0, 5, 5, 5, 0,
1, 1, 1, 0, 3, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0,
4, 4, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 4,
8, 3, 8, 6, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2
};
return offset_data[c];
}
static u8* mFont_Get_FontTex_p() {
return FONT_nes_tex_font1;
}
extern int mFont_GetCodeWidth(int c, int cut) {
return mFont_TEX_CHAR_WIDTH - (cut ? mFont_Get_FontOffset(c) : 0);
}
extern int mFont_GetStringWidth(u8* str, int len, int cut) {
int width = 0;
int i;
for (i = 0; i < len; i++) {
width += mFont_GetCodeWidth(str[i], cut);
}
return width;
}
extern int mFont_GetStringWidth2(u8* str, int len, int cut) {
int width = 0;
int i;
int skip_size;
for (i = 0; i < len; i += skip_size) {
u8 c = str[i];
if (c != CHAR_CONTROL_CODE) {
width += mFont_GetCodeWidth(c, cut);
}
skip_size = mFont_CodeSize_get(str + i);
}
return width;
}
typedef struct control_code_s {
s8 size;
s8 attribute;
} mFont_ControlCodeInfo_t;
static mFont_ControlCodeInfo_t mFont_cont_info_tbl[mFont_CONT_CODE_NUM] = {
{ 2, mFont_CONT_ATTRIBUTE_0 },
{ 2, mFont_CONT_ATTRIBUTE_0 },
{ 2, mFont_CONT_ATTRIBUTE_0 },
{ 3, mFont_CONT_ATTRIBUTE_0 },
{ 2, mFont_CONT_ATTRIBUTE_0 },
{ 5, mFont_CONT_ATTRIBUTE_0 },
{ 2, mFont_CONT_ATTRIBUTE_0 },
{ 2, mFont_CONT_ATTRIBUTE_0 },
{ 5, mFont_CONT_ATTRIBUTE_DEMO },
{ 5, mFont_CONT_ATTRIBUTE_DEMO },
{ 5, mFont_CONT_ATTRIBUTE_DEMO },
{ 5, mFont_CONT_ATTRIBUTE_DEMO },
{ 5, mFont_CONT_ATTRIBUTE_DEMO },
{ 2, mFont_CONT_ATTRIBUTE_0 },
{ 4, mFont_CONT_ATTRIBUTE_0 },
{ 4, mFont_CONT_ATTRIBUTE_0 },
{ 4, mFont_CONT_ATTRIBUTE_0 },
{ 4, mFont_CONT_ATTRIBUTE_0 },
{ 4, mFont_CONT_ATTRIBUTE_0 },
{ 6, mFont_CONT_ATTRIBUTE_0 },
{ 8, mFont_CONT_ATTRIBUTE_0 },
{ 10, mFont_CONT_ATTRIBUTE_0 },
{ 6, mFont_CONT_ATTRIBUTE_0 },
{ 8, mFont_CONT_ATTRIBUTE_0 },
{ 10, mFont_CONT_ATTRIBUTE_0 },
{ 2, mFont_CONT_ATTRIBUTE_0 },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_3 },
{ 2, mFont_CONT_ATTRIBUTE_3 },
{ 2, mFont_CONT_ATTRIBUTE_3 },
{ 2, mFont_CONT_ATTRIBUTE_3 },
{ 2, mFont_CONT_ATTRIBUTE_3 },
{ 2, mFont_CONT_ATTRIBUTE_3 },
{ 2, mFont_CONT_ATTRIBUTE_3 },
{ 2, mFont_CONT_ATTRIBUTE_3 },
{ 2, mFont_CONT_ATTRIBUTE_3 },
{ 2, mFont_CONT_ATTRIBUTE_3 },
{ 2, mFont_CONT_ATTRIBUTE_3 },
{ 2, mFont_CONT_ATTRIBUTE_3 },
{ 2, mFont_CONT_ATTRIBUTE_3 },
{ 2, mFont_CONT_ATTRIBUTE_3 },
{ 2, mFont_CONT_ATTRIBUTE_3 },
{ 6, mFont_CONT_ATTRIBUTE_CHARACTER },
{ 3, mFont_CONT_ATTRIBUTE_0 },
{ 3, mFont_CONT_ATTRIBUTE_SENTENCE },
{ 3, mFont_CONT_ATTRIBUTE_SENTENCE },
{ 3, mFont_CONT_ATTRIBUTE_CHARACTER },
{ 2, mFont_CONT_ATTRIBUTE_0 },
{ 4, mFont_CONT_ATTRIBUTE_BGM },
{ 4, mFont_CONT_ATTRIBUTE_BGM },
{ 3, mFont_CONT_ATTRIBUTE_0 },
{ 3, mFont_CONT_ATTRIBUTE_SE },
{ 3, mFont_CONT_ATTRIBUTE_SENTENCE },
{ 2, mFont_CONT_ATTRIBUTE_SE },
{ 2, mFont_CONT_ATTRIBUTE_3 },
{ 2, mFont_CONT_ATTRIBUTE_3 },
{ 2, mFont_CONT_ATTRIBUTE_0 },
{ 2, mFont_CONT_ATTRIBUTE_0 },
{ 2, mFont_CONT_ATTRIBUTE_0 },
{ 2, mFont_CONT_ATTRIBUTE_3 },
{ 2, mFont_CONT_ATTRIBUTE_0 },
{ 6, mFont_CONT_ATTRIBUTE_0 },
{ 3, mFont_CONT_ATTRIBUTE_AGB_DUMMY },
{ 3, mFont_CONT_ATTRIBUTE_AGB_DUMMY },
{ 4, mFont_CONT_ATTRIBUTE_AGB_DUMMY },
{ 3, mFont_CONT_ATTRIBUTE_SENTENCE },
{ 2, mFont_CONT_ATTRIBUTE_AGB_DUMMY },
{ 2, mFont_CONT_ATTRIBUTE_AGB_DUMMY },
{ 6, mFont_CONT_ATTRIBUTE_0 },
{ 2, mFont_CONT_ATTRIBUTE_AGB_DUMMY },
{ 2, mFont_CONT_ATTRIBUTE_AGB_DUMMY },
{ 3, mFont_CONT_ATTRIBUTE_AGB_DUMMY },
{ 3, mFont_CONT_ATTRIBUTE_AGB_DUMMY },
{ 3, mFont_CONT_ATTRIBUTE_AGB_DUMMY },
{ 3, mFont_CONT_ATTRIBUTE_AGB_DUMMY },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 2, mFont_CONT_ATTRIBUTE_0 },
{ 2, mFont_CONT_ATTRIBUTE_0 },
{ 2, mFont_CONT_ATTRIBUTE_0 },
{ 2, mFont_CONT_ATTRIBUTE_0 },
{ 2, mFont_CONT_ATTRIBUTE_STRING },
{ 4, mFont_CONT_ATTRIBUTE_0 },
{ 4, mFont_CONT_ATTRIBUTE_0 },
{ 12, mFont_CONT_ATTRIBUTE_0 },
{ 14, mFont_CONT_ATTRIBUTE_0 }
};
extern int mFont_CodeSize_get(u8* str) {
int size = 1;
int c0 = *str;
int c1;
if (c0 == CHAR_CONTROL_CODE) {
c1 = *(str + 1);
if (c1 >= 0 && c1 < mFont_CONT_CODE_NUM) {
size = mFont_cont_info_tbl[c1].size;
}
else {
size = 2;
}
}
else if (c0 == CHAR_MESSAGE_TAG) {
size = 2;
}
return size;
}
extern int mFont_CodeSize_idx_get(u8* str, int idx) {
return mFont_CodeSize_get(str + idx);
}
extern int mFont_cont_attr_get(int cont_code) {
return mFont_cont_info_tbl[cont_code].attribute;
}
extern void mFont_gppSetMode(Gfx** gfx_pp) {
static Gfx disp[] = {
gsDPPipeSync(),
gsSPTexture(0x8000, 0x8000, 0, G_TX_RENDERTILE, G_ON),
gsSPClearGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
gsDPSetTextureLOD(G_TL_TILE),
gsDPSetTextureConvert(G_TC_FILT),
gsDPSetTextureLUT(G_TT_NONE),
gsDPSetTextureFilter(G_TF_BILERP),
gsDPSetCycleType(G_CYC_1CYCLE),
gsDPSetTexturePersp(G_TP_PERSP),
gsDPSetCombineMode(mFont_CC_FONT, mFont_CC_FONT),
gsDPSetRenderMode(G_RM_XLU_SURF, G_RM_XLU_SURF2),
gsDPSetPrimColor(0, 0, 255, 255, 255, 255),
gsSPEndDisplayList()
};
gSPDisplayList((*gfx_pp)++, disp);
}
extern void mFont_SetMode(GRAPH* graph, int mode) {
Gfx* g;
OPEN_DISP(graph);
if (mode == 0) {
g = NOW_POLY_OPA_DISP;
mFont_gppSetMode(&g);
SET_POLY_OPA_DISP(g);
}
else {
g = NOW_FONT_DISP;
mFont_gppSetMode(&g);
SET_FONT_DISP(g);
}
CLOSE_DISP(graph);
}
static Gfx* mFont_gfxSetPrimColor(Gfx* gfx, int r, int g, int b, int a) {
gDPSetPrimColor(gfx++, 0, 0, r, g, b, a);
return gfx;
}
static Gfx* mFont_gppSetPrimColor(Gfx** gpp, rgba_t* color) {
Gfx* g = *gpp;
gDPSetPrimColor(
g++,
0, 0,
color->r,
color->g,
color->b,
color->a
);
*gpp = g;
}
extern void mFont_SetPrimColor(GRAPH* graph, int r, int g, int b, int a, int mode) {
Gfx* gfx;
OPEN_DISP(graph);
if (mode == 0) {
gfx = NOW_POLY_OPA_DISP;
gfx = mFont_gfxSetPrimColor(gfx, r, g, b, a);
SET_POLY_OPA_DISP(gfx);
}
else {
gfx = NOW_FONT_DISP;
gfx = mFont_gfxSetPrimColor(gfx, r, g, b, a);
SET_FONT_DISP(gfx);
}
CLOSE_DISP(graph);
}
static Gfx* mFont_gfxSetCombineMode(Gfx* gfx, int no_font, int sync) {
if (sync) {
gDPPipeSync(gfx++);
}
if (no_font) {
gDPSetCombineMode(gfx++, mFont_CC_FONT, mFont_CC_NOFONT);
}
else {
gDPSetCombineMode(gfx++, mFont_CC_FONT, mFont_CC_FONT);
}
return gfx;
}
static void mFont_gppSetCombineMode(Gfx** gpp, int no_font, int sync) {
Gfx* g = *gpp;
if (sync) {
gDPPipeSync(g++);
}
if (no_font) {
gDPSetCombineMode(g++, mFont_CC_FONT, mFont_CC_NOFONT);
}
else {
gDPSetCombineMode(g++, mFont_CC_FONT, mFont_CC_FONT);
}
*gpp = g;
}
extern void mFont_SetCombineMode(GRAPH* graph, int revert_flag, int mode) {
Gfx* g;
OPEN_DISP(graph);
if (mode == 0) {
g = NOW_POLY_OPA_DISP;
g = mFont_gfxSetCombineMode(g, revert_flag, TRUE);
SET_POLY_OPA_DISP(g);
}
else {
g = NOW_FONT_DISP;
g = mFont_gfxSetCombineMode(g, revert_flag, TRUE);
SET_FONT_DISP(g);
}
CLOSE_DISP(graph);
}
static void mFont_gppLoadTexture(Gfx** gpp, int c, int* uls, int* ult, int* lrs, int* lrt) {
Gfx* g = *gpp;
u8* font_tex = mFont_Get_FontTex_p();
int t = c >> 4;
int n_ult = t << 4;
int n_uls = (c - n_ult) * mFont_TEX_CHAR_WIDTH;
int n_lrs = n_uls + (mFont_TEX_CHAR_WIDTH - 1);
int n_lrt = n_ult + (mFont_TEX_CHAR_HEIGHT - 1);
gDPLoadTextureTile_4b_Dolphin(
g++,
font_tex,
G_IM_FMT_I,
mFont_TEX_CHAR_WIDTH * 16, mFont_TEX_CHAR_HEIGHT * 16
);
*gpp = g;
*uls = n_uls;
*ult = n_ult;
*lrs = n_lrs;
*lrt = n_lrt;
}
static void mFont_SetVertex_dol(Vtx* vtx, int x, int y, int s, int t) {
vtx->v.ob[0] = x;
vtx->v.ob[1] = y;
vtx->v.ob[2] = 0;
vtx->v.flag = 1;
vtx->v.tc[0] = s;
vtx->v.tc[1] = t;
vtx->v.cn[0] = 0;
vtx->v.cn[1] = 0;
vtx->v.cn[2] = 0;
vtx->v.cn[3] = 0;
}
// TEMP
#define SCREEN_WIDTH 320
#define SCREEN_HEIGHT 240
#define HALF_SCR_WIDTH ((f32)(SCREEN_WIDTH / 2))
#define HALF_SCR_HEIGHT ((f32)(SCREEN_HEIGHT / 2))
#define NHALF_SCR_WIDTH ((f32)(-SCREEN_WIDTH / 2))
#define NHALF_SCR_HEIGHT ((f32)(-SCREEN_HEIGHT / 2))
extern f32 mFont_SetVertexRectangle(
GAME* game,
f32 x, f32 y,
int s, int t,
f32 scale_x, f32 scale_y,
int mode
) {
f32 sS = ((f32)s) * scale_x;
f32 sT = ((f32)t) * scale_y;
f32 n = x + sS;
f32 pos_x = x - HALF_SCR_WIDTH;
f32 pos_y = -y + HALF_SCR_HEIGHT;
f32 start_x = pos_x;
f32 start_y = pos_y;
f32 end_x = start_x + sS;
f32 end_y = start_y - sT;
f32 l_ofs = 0.0f;
f32 r_ofs = 0.0f;
f32 t_ofs = 0.0f;
f32 b_ofs = 0.0f;
if (start_x > HALF_SCR_WIDTH ||
start_y < NHALF_SCR_HEIGHT ||
end_x < NHALF_SCR_WIDTH ||
end_y > HALF_SCR_HEIGHT)
{
return n;
}
{
f32 dist_l = start_x - NHALF_SCR_WIDTH;
f32 dist_t = start_y - HALF_SCR_HEIGHT;
f32 dist_r = end_x - HALF_SCR_WIDTH;
f32 dist_b = end_y - NHALF_SCR_HEIGHT;
if (dist_l < 0.0f) {
start_x = NHALF_SCR_WIDTH;
l_ofs -= dist_l;
}
if (dist_t > 0.0f) {
start_y = HALF_SCR_HEIGHT;
t_ofs += dist_t;
}
if (dist_r > 0.0f) {
end_x = HALF_SCR_WIDTH;
r_ofs += dist_r;
}
if (dist_b < 0.0f) {
end_y = NHALF_SCR_HEIGHT;
b_ofs -= dist_b;
}
}
{
f32 inv_scale_x = 1.0f / scale_x;
f32 inv_scale_y = 1.0f / scale_y;
int vert_left_s = (int)(l_ofs * inv_scale_x) << 6;
int vert_top_t = (int)(t_ofs * inv_scale_y) << 6;
int vert_right_s = (int)(((f32)s) - r_ofs * inv_scale_x) << 6;
int vert_bot_t = (int)(((f32)t) - b_ofs * inv_scale_y) << 6;
int vert_left_x = (int)(start_x * mFont_SCALE_F);
int vert_top_y = (int)(start_y * mFont_SCALE_F);
int vert_right_x = (int)(end_x * mFont_SCALE_F);
int vert_bot_y = (int)(end_y * mFont_SCALE_F);
Vtx* vtx = GRAPH_ALLOC_TYPE(game->graph, Vtx, 4);
Gfx* gfx = GRAPH_ALLOC_TYPE(game->graph, Gfx, 3);
if (vtx != NULL && gfx != NULL) {
mFont_SetVertex_dol(vtx++, vert_left_x, vert_top_y, vert_left_s, vert_top_t);
mFont_SetVertex_dol(vtx++, vert_right_x, vert_top_y, vert_right_s, vert_top_t);
mFont_SetVertex_dol(vtx++, vert_right_x, vert_bot_y, vert_right_s, vert_bot_t);
mFont_SetVertex_dol(vtx, vert_left_x, vert_bot_y, vert_left_s, vert_bot_t);
OPEN_DISP(game->graph);
if (mode == 1) {
gSPDisplayList(NOW_FONT_DISP++, gfx);
}
else {
gSPDisplayList(NOW_POLY_OPA_DISP++, gfx);
}
CLOSE_DISP(game->graph);
gSPVertex(gfx++, vtx - 3, 4, 0);
gSPNTrianglesInit_5b(
gfx++,
2, // 2 triangles
0, 2, 1, // 0 -> 2 -> 1
0, 3, 2, // 0 -> 3 -> 2
0, 0, 0 // unused
);
gSPEndDisplayList(gfx);
}
}
return n;
}
static f32 mFont_SetLineStrings_AndSpace_new(
GAME* game,
u8* str,
int len,
f32 x, f32 y,
int r, int g, int b, int a,
int flag_revert, int flag_cut,
int unused,
f32 scale_x, f32 scale_y,
int mode
) {
Gfx* g;
mFontSentence sentence;
int use_polygon_opaque = mode == 0;
u32 flag;
xy_t pos;
xy_t scale;
rgba_t color;
if (fabsf(scale_x) < 0.001f || fabsf(scale_y) < 0.001f) {
return 0.0f;
}
if (len <= 0) {
return 0.0f;
}
OPEN_DISP(game->graph);
if (use_polygon_opaque) {
g = NOW_POLY_OPA_DISP;
}
else {
g = NOW_FONT_DISP;
}
flag = mFont_SENTENCE_FLAG_USE_POLY;
if (flag_revert) {
flag |= mFont_SENTENCE_FLAG_REVERT;
}
if (flag_cut) {
flag |= mFont_SENTENCE_FLAG_CUT;
}
pos.x = x;
pos.y = y;
scale.x = scale_x;
scale.y = scale_y;
color.r = r;
color.g = g;
color.b = b;
color.a = a;
mFontSentence_set(&sentence, str, len, flag, &pos, mFont_LineType_Top, &scale, &color, 0, 0, 0, 0, 0);
mFontSentence_gppDraw(&sentence, game, &g);
if (use_polygon_opaque) {
SET_POLY_OPA_DISP(g);
}
else {
SET_FONT_DISP(g);
}
CLOSE_DISP(game->graph);
return sentence.width;
}
extern f32 mFont_SetLineStrings_AndSpace(
GAME* game,
u8* str,
int len,
f32 x, f32 y,
int r, int g, int b, int a,
int flag_revert, int flag_cut,
int unused,
f32 scale_x, f32 scale_y,
int mode
) {
return mFont_SetLineStrings_AndSpace_new(
game,
str,
len,
x, y,
r, g, b, a,
flag_revert, flag_cut,
unused,
scale_x, scale_y,
mode
);
}
extern f32 mFont_SetLineStrings(
GAME* game,
u8* str,
int len,
f32 x, f32 y,
int r, int g, int b, int a,
int flag_revert, int flag_cut,
f32 scale_x, f32 scale_y,
int mode
) {
return mFont_SetLineStrings_AndSpace(
game,
str,
len,
x, y,
r, g, b, a,
flag_revert, flag_cut,
0,
scale_x, scale_y,
mode
);
}
extern void mFont_CulcOrthoMatrix(Mtx* m) {
guOrtho(
m,
NHALF_SCR_WIDTH * mFont_SCALE_F, HALF_SCR_WIDTH * mFont_SCALE_F,
NHALF_SCR_HEIGHT * mFont_SCALE_F, HALF_SCR_HEIGHT * mFont_SCALE_F,
-800.0f, 800.0f,
1.0f
);
}
extern void mFont_SetMatrix(GRAPH* graph, int mode) {
static Mtx mtx_projection;
static int first = TRUE;
if (first) {
mFont_CulcOrthoMatrix(&mtx_projection);
first = FALSE;
}
Matrix_push();
Matrix_put(&MtxF_clear);
OPEN_DISP(graph);
if (mode == 1) {
gSPMatrix(NOW_FONT_DISP++, &mtx_projection, G_MTX_PROJECTION | G_MTX_LOAD | G_MTX_NOPUSH);
gSPMatrix(NOW_FONT_DISP++, &Mtx_clear, G_MTX_MODELVIEW | G_MTX_LOAD | G_MTX_NOPUSH);
}
else {
gSPMatrix(NOW_POLY_OPA_DISP++, &mtx_projection, G_MTX_PROJECTION | G_MTX_LOAD | G_MTX_NOPUSH);
gSPMatrix(NOW_POLY_OPA_DISP++, &Mtx_clear, G_MTX_MODELVIEW | G_MTX_LOAD | G_MTX_NOPUSH);
}
CLOSE_DISP(graph);
}
extern void mFont_UnSetMatrix(GRAPH* graph, int mode) {
Matrix_pull();
}
extern void mFont_Main_start(GRAPH* graph) {
mFont_SetMode(graph, 1);
}
/* @unused f32 mFont_Get_NextCharRectX(???) */
/* @unused f32 mFont_Get_NextCharRectY(???) */
static void mFont_gppDrawCharRect(
GRAPH* graph,
Gfx** gfx_pp,
int c,
u32 ulx, u32 uly,
u32 lrx, u32 lry,
int dsdx, int dtdy
) {
Gfx* g = *gfx_pp;
int uls;
int ult;
int lrs;
int lrt;
mFont_gppLoadTexture(&g, c, &uls, &ult, &lrs, &lrt);
// Convert to signed 10.5 format
uls <<= 5;
ult <<= 5;
g = gfx_gSPTextureRectangle1(g, ulx, uly, lrx, lry, G_TX_RENDERTILE, (int)uls, (int)ult, dsdx, dtdy);
*gfx_pp = g;
}
// TODO: Non-matching
static void mFont_gppDrawCharPoly(
GRAPH* graph,
Gfx** gfx_pp,
int c,
xy_t* pos_tl, xy_t* pos_br,
int s, int t
) {
Gfx* g = *gfx_pp;
Vtx* vtx = GRAPH_ALLOC_TYPE(graph, Vtx, 4);
int uls, ult, lrs, lrt;
int ulx, uly, lrx, lry;
xy_t vert_tl, vert_br;
f32 inv_half_s, inv_half_t;
mFont_gppLoadTexture(&g, c, &uls, &ult, &lrs, &lrt);
vert_tl.x = pos_tl->x - ((f32)SCREEN_WIDTH * 0.5f);
vert_tl.y = -(pos_tl->y - ((f32)SCREEN_HEIGHT * 0.5f));
vert_br.x = pos_br->x - ((f32)SCREEN_WIDTH * 0.5f) - vert_tl.x;
vert_br.y = -(pos_br->y - ((f32)SCREEN_HEIGHT * 0.5f)) - vert_tl.y;
inv_half_s = 0.5f / (f32)s;
inv_half_t = 0.5f / (f32)t;
ulx = (vert_tl.x + vert_br.x * inv_half_s) * mFont_SCALE_F;
uly = (vert_tl.y + vert_br.y * inv_half_t) * mFont_SCALE_F;
lrx = (vert_tl.x + vert_br.x * (1.0f - inv_half_s)) * mFont_SCALE_F;
lry = (vert_tl.y + vert_br.y * (1.0f - inv_half_t)) * mFont_SCALE_F;
lrs = ((uls + s) << 6) - 32;
lrt = ((ult + t) << 6) - 32;
uls = (uls << 6) + 32;
ult = (ult << 6) + 32;
mFont_SetVertex_dol(vtx + 0, ulx, uly, uls, ult);
mFont_SetVertex_dol(vtx + 1, ulx, lry, uls, lrt);
mFont_SetVertex_dol(vtx + 2, lrx, lry, lrs, lrt);
mFont_SetVertex_dol(vtx + 3, lrx, uly, lrs, ult);
gSPVertex(g++, vtx, 4, 0);
gSPNTrianglesInit_5b(
g++,
2, // 2 tris
0, 1, 2, // tri 1
0, 2, 3, // tri 2
0, 0, 0 // unused
);
*gfx_pp = g;
}
static void mFontChar_gppDraw_sentence_restore(mFontChar* this, mFontSentence* sentence, Gfx** gfx_pp) {
if (this->color_ctr > 0) {
this->color_ctr--;
if (this->color_ctr == 0) {
rgba_t_move(&this->color, &sentence->color);
mFont_gppSetPrimColor(gfx_pp, &this->color);
}
}
if ((this->flags & mFont_CHAR_FLAG_SCALE)) {
this->scale.x = 1.0f;
this->scale.y = 1.0f;
this->inv_scale.x = 1.0f;
this->inv_scale.y = 1.0f;
this->flags &= ~mFont_CHAR_FLAG_SCALE;
this->flags |= mFont_CHAR_FLAG_SCALE_RESET;
}
}
static void mFontChar_total_scale_reset(mFontChar* this, mFontSentence* sentence) {
if ((this->flags & mFont_CHAR_FLAG_SCALE_RESET)) {
this->scaled_size.x = this->scale.x * sentence->scale.x * sentence->line_scale;
this->scaled_size.y = this->scale.y * sentence->scale.y * sentence->line_scale;
this->inv_scaled_size.x = this->inv_scale.x * sentence->inv_scale.x * sentence->inv_line_scale;
this->inv_scaled_size.y = this->inv_scale.y * sentence->inv_scale.y * sentence->inv_line_scale;
this->flags &= ~mFont_CHAR_FLAG_SCALE_RESET;
}
}
static void mFontChar_ContProc_set_color_char(mFontChar* this, Gfx** gfx_pp) {
this->color.r = this->char_p[2];
this->color.g = this->char_p[3];
this->color.b = this->char_p[4];
this->color.a = 255;
this->color_ctr = this->char_p[5];
mFont_gppSetPrimColor(gfx_pp, &this->color);
}
static void mFontChar_ContProc_set_char_scale(mFontChar* this, Gfx** gfx_pp) {
int scale_val = this->char_p[2];
f32 scale = (f32)scale_val * (1.0f / 32.0f);
f32 inv_scale = 1.0f / scale;
this->scale.x = scale;
this->scale.y = scale;
this->inv_scale.x = inv_scale;
this->inv_scale.y = inv_scale;
this->flags |= (mFont_CHAR_FLAG_SCALE | mFont_CHAR_FLAG_SCALE_RESET);
}
static mFont_ControlCodeCharFunc mFontChar_cont_proc_get(int control_code) {
if (control_code == mFont_CONT_CODE_SET_COLOR_CHAR) {
return mFontChar_ContProc_set_color_char;
}
else if (control_code == mFont_CONT_CODE_SET_CHAR_SCALE) {
return mFontChar_ContProc_set_char_scale;
}
else {
return NULL;
}
}
static void mFontChar_set(
mFontChar* this,
u8* char_p, int len,
u8 flags,
xy_t* pos,
xy_t* scale, xy_t* inv_scale,
f32 ofs_y,
rgba_t* color
) {
bzero(this, sizeof(mFontChar));
this->char_p = char_p;
this->len = len;
this->flags = flags;
this->position = *pos;
this->scale = *scale;
this->inv_scale = *inv_scale;
this->ofs_y = ofs_y;
rgba_t_move(&this->color, color);
}
static void mFontChar_gppDrawRect(mFontChar* this, GRAPH* graph, Gfx** gfx_pp) {
u32 ulx, uly, lrx, lry;
int dsdx, dtdy;
f32 t;
f32 width;
t = -this->ofs_y;
uly = (int)((t * this->scaled_size.y - t + this->position.y) * 4.0f);
t = mFont_TEX_CHAR_HEIGHT_F32 - this->ofs_y;
lry = (int)((t * this->scaled_size.y - t + this->position.y + mFont_TEX_CHAR_HEIGHT_F32) * 4.0f);
ulx = (int)(this->position.x * 4.0f);
width = (f32)mFont_GetCodeWidth(*this->char_p, this->flags & mFont_CHAR_FLAG_CUT) * this->scaled_size.x;
lrx = (int)((width + this->position.x) * 4.0f);
dsdx = (1024.0f * this->inv_scaled_size.x); /* 1 << 10 for correct s5.10 format? */
dtdy = (1024.0f * this->inv_scaled_size.y); /* 1 << 10 for correct s5.10 format? */
this->width = width;
mFont_gppDrawCharRect(graph, gfx_pp, *this->char_p, ulx, uly, lrx, lry, dsdx, dtdy);
}
// TODO: match
static void mFontChar_gppDrawPoly(mFontChar* this, GRAPH* graph, Gfx** gfx_pp) {
xy_t top_left;
xy_t bottom_right;
f32 t;
f32 width;
int s;
int c = *this->char_p;
t = -this->ofs_y;
top_left.y = (t * this->scaled_size.y) - t + this->position.y;
t = mFont_TEX_CHAR_HEIGHT_F32 - this->ofs_y;
bottom_right.y = (t * this->scaled_size.y) - t + this->position.y + mFont_TEX_CHAR_HEIGHT_F32;
top_left.x = this->position.x;
s = mFont_GetCodeWidth(c, this->flags & mFont_CHAR_FLAG_CUT);
width = s * this->scaled_size.x;
bottom_right.x = width + this->position.x;
this->width = width;
mFont_gppDrawCharPoly(graph, gfx_pp, c, &top_left, &bottom_right, s, mFont_TEX_CHAR_HEIGHT);
}
static void mFontChar_gppDraw(mFontChar* this, GRAPH* graph, Gfx** gfx_pp) {
if (this->flags & mFont_CHAR_FLAG_USE_POLY) {
mFontChar_gppDrawPoly(this, graph, gfx_pp);
}
else {
mFontChar_gppDrawRect(this, graph, gfx_pp);
}
}
static f32 mFontSentence_line_offset_calc(int line_type) {
static f32 offset_value[mFont_LineType_End] = {
mFont_TEX_CHAR_HEIGHT_F32 * 0.0f,
mFont_TEX_CHAR_HEIGHT_F32 * 0.5f,
mFont_TEX_CHAR_HEIGHT_F32 * 1.0f
};
return offset_value[line_type];
}
static void mFontSentence_ContProc_set_line_offset(mFontSentence* this, Gfx** gfx_pp) {
mFontChar* character = &this->character;
int t = (u8)(*(this->sentence_p + this->now_idx + 2)) - 128;
this->offset = t;
character->position.y = this->position.y + this->offset;
}
static void mFontSentence_ContProc_set_line_type(mFontSentence* this, Gfx** gfx_pp) {
mFontChar* character = &this->character;
int type = *(this->sentence_p + this->now_idx + 2);
this->line_type = type;
character->ofs_y = mFontSentence_line_offset_calc(this->line_type);
}
static void mFontSentence_ContProc_set_line_scale(mFontSentence* this, Gfx** gfx_pp) {
mFontChar* character = &this->character;
int scale = *(this->sentence_p + this->now_idx + 2);
f32 f_scale = (f32)scale * (1.0f / 32.0f);
f32 f_inv_scale = 1.0f / f_scale;
this->line_scale = f_scale;
this->inv_line_scale = f_inv_scale;
character->flags |= mFont_CHAR_FLAG_SCALE_RESET;
}
static void mFontSentence_ContProc_space(mFontSentence* this, Gfx** gfx_pp) {
mFontChar* character = &this->character;
int c = *(this->sentence_p + this->now_idx + 2);
this->width += c * character->scaled_size.x;
}
static mFont_ControlCodeSentenceFunc mFontSentence_cont_proc_get(int control_code) {
if (control_code == mFont_CONT_CODE_SET_LINE_OFFSET) {
return mFontSentence_ContProc_set_line_offset;
}
else if (control_code == mFont_CONT_CODE_SET_LINE_TYPE) {
return mFontSentence_ContProc_set_line_type;
}
else if (control_code == mFont_CONT_CODE_SET_LINE_SCALE) {
return mFontSentence_ContProc_set_line_scale;
}
else if (control_code == mFont_CONT_CODE_SPACE) {
return mFontSentence_ContProc_space;
}
else {
return NULL;
}
}
static void mFontSentence_animal_voice_se(mFontSentence* this) {
mFontChar* character = &this->character;
f32 f_scale;
int scale;
f_scale = character->scale.x * character->scale.x + character->scale.y * character->scale.y;
f_scale = sqrtf(f_scale);
scale = this->line_scale * f_scale * (32.0f / SQRT_OF_2_F) + 0.5f;
scale = scale < 0 ? 0 : (scale > 255 ? 255 : scale);
// TODO: these definitely deserve to be promoted to defines or enums in the future.
// Unsure which sfx & case this is referring to.
if (this->voice_idx == 0x80 && this->se_character_id != 0 && scale == 32 &&
character->color.r == 50 && character->color.g == 60 && character->color.b == 50 && character->color.a == 255) {
this->se_character_id = 0;
}
sAdo_VoiceSe(this->voice_idx, this->voice2_idx, this->voice3_idx, this->se_character_id, (u8)scale, 0);
}
extern void mFontSentence_set(
mFontSentence* this,
u8* sentence_p, int len,
u32 flags,
xy_t* pos,
int line_type,
xy_t* scale,
rgba_t* color,
int se_voice_pos,
u8 voice_idx, u8 voice2_idx, u8 voice3_idx,
s16 voice_se_character_idx
) {
static xy_t unit_vec_xy = { 1.0f, 1.0f };
u8 character_flags = 0;
bzero(this, sizeof(mFontSentence));
this->sentence_p = sentence_p;
this->len = len;
this->flags = flags;
this->position = *pos;
this->line_type = line_type;
this->scale = *scale;
this->inv_scale.x = 1.0f / scale->x;
this->inv_scale.y = 1.0f / scale->y;
this->line_scale = 1.0f;
this->inv_line_scale = 1.0f;
rgba_t_move(&this->color, color);
this->se_pos = se_voice_pos;
this->voice_idx = voice_idx;
this->voice2_idx = voice2_idx;
this->voice3_idx = voice3_idx;
this->se_character_id = voice_se_character_idx;
if (this->flags & mFont_SENTENCE_FLAG_CUT) {
character_flags |= mFont_CHAR_FLAG_CUT;
}
if (this->flags & mFont_SENTENCE_FLAG_USE_POLY) {
character_flags |= mFont_CHAR_FLAG_USE_POLY;
}
character_flags |= mFont_CHAR_FLAG_SCALE_RESET;
mFontChar_set(
&this->character,
this->sentence_p,
1,
character_flags,
&this->position,
&unit_vec_xy,
&unit_vec_xy,
mFontSentence_line_offset_calc(this->line_type),
&this->color
);
}
static void mFontSentence_gppDraw_before(mFontSentence* this, Gfx** gfx_pp) {
if (!(this->flags & mFont_SENTENCE_FLAG_3)) {
if (this->flags & mFont_SENTENCE_FLAG_USE_POLY) {
mFont_gppSetMode(gfx_pp);
}
else {
mFont_gppSetRectMode(gfx_pp);
}
}
if (!(this->flags & mFont_SENTENCE_FLAG_NO_COMBINE)) {
mFont_gppSetCombineMode(gfx_pp, this->flags & mFont_SENTENCE_FLAG_REVERT, FALSE);
}
if (!(this->flags & mFont_SENTENCE_FLAG_NO_COLOR)) {
mFont_gppSetPrimColor(gfx_pp, &this->color);
}
}
static void mFontSentence_gppDraw_main(mFontSentence* this, GAME* game, Gfx** gfx_pp) {
GRAPH* graph = game->graph;
u8* char_p = this->sentence_p + this->now_idx;
int c = *char_p;
int char_size = mFont_CodeSize_get(char_p);
this->character.char_p = char_p;
this->character.len = char_size;
if (c == CHAR_CONTROL_CODE) {
int next = *(char_p + 1);
int type = mFont_cont_attr_get(next);
if (type == mFont_CONT_ATTRIBUTE_SENTENCE) {
(mFontSentence_cont_proc_get(next))(this, gfx_pp);
}
else if (type == mFont_CONT_ATTRIBUTE_CHARACTER) {
(mFontChar_cont_proc_get(next))(&this->character, gfx_pp);
}
}
else {
if (!((this->flags & mFont_SENTENCE_SKIP_DRAW_NEW_LINE) && c == CHAR_NEW_LINE)) {
this->character.position.x = this->position.x + this->width;
mFontChar_total_scale_reset(&this->character, this);
mFontChar_gppDraw(&this->character, graph, gfx_pp);
if ((this->flags & mFont_SENTENCE_FLAG_VOICE_SE) && this->now_idx == this->se_pos) {
mFontSentence_animal_voice_se(this);
}
this->width += this->character.width;
mFontChar_gppDraw_sentence_restore(&this->character, this, gfx_pp);
}
}
this->now_idx += char_size;
}
static void mFontSentence_gppDraw_after(mFontSentence* this, Gfx** gfx_pp) {
}
extern void mFontSentence_gppDraw(mFontSentence* this, GAME* game, Gfx** gfx_pp) {
mFontSentence_gppDraw_before(this, gfx_pp);
while (this->now_idx < this->len) {
mFontSentence_gppDraw_main(this, game, gfx_pp);
}
mFontSentence_gppDraw_after(this, gfx_pp);
}
static u8* mFont_Get_MarkTex_p(int mark_type) {
static u8* tex_p_array[mFont_MARKTYPE_TOTAL] = {
FONT_nes_tex_jyouge,
FONT_nes_tex_sayuu,
FONT_nes_tex_cursor,
FONT_nes_tex_next,
FONT_nes_tex_choice
};
if (0 <= mark_type && mark_type < mFont_MARKTYPE_TOTAL && tex_p_array[mark_type] != NULL) {
return tex_p_array[mark_type];
}
return NULL;
}
static int mFont_Get_MarkTex_sizeW(int mark_type) {
static int size_array[mFont_MARKTYPE_TOTAL] = { 16, 16, 16, 16, 16 };
if (0 <= mark_type && mark_type < mFont_MARKTYPE_TOTAL && size_array[mark_type] != 0) {
return size_array[mark_type];
}
return 0;
}
static int mFont_Get_MarkTex_sizeH(int mark_type) {
static int size_array[mFont_MARKTYPE_TOTAL] = { 16, 16, 16, 16, 16 };
if (0 <= mark_type && mark_type < mFont_MARKTYPE_TOTAL && size_array[mark_type] != 0) {
return size_array[mark_type];
}
return 0;
}
// TODO: match
extern f32 mFont_SetMarkChar(
GAME* game,
u8 mark_type,
f32 x, f32 y,
int r, int g, int b, int a,
int revert_flag,
f32 scale_x, f32 scale_y,
int mode
) {
f32 next_x = x;
if ((int)mark_type < mFont_MARKTYPE_TOTAL) {
u8* tex = mFont_Get_MarkTex_p(mark_type);
int w = mFont_Get_MarkTex_sizeW(mark_type);
int h = mFont_Get_MarkTex_sizeH(mark_type);
GRAPH* graph = game->graph;
Gfx* gfx = GRAPH_ALLOC_TYPE(graph, Gfx, 9);
if (tex != NULL && w != 0 && h != 0 && gfx != NULL) {
mFont_SetMode(graph, mode);
mFont_SetPrimColor(graph, r, g, b, a, mode);
mFont_SetCombineMode(graph, revert_flag, mode);
OPEN_DISP(graph);
if (mode == 1) {
gSPDisplayList(NOW_FONT_DISP++, gfx);
}
else {
gSPDisplayList(NOW_POLY_OPA_DISP++, gfx);
}
CLOSE_DISP(graph);
/* TODO: they seem to have a secondary macro that does the operations directly */
gDPLoadTextureTile_4b_Dolphin(
gfx++,
tex,
G_IM_FMT_I,
w, h + mFont_TEX_CHAR_HEIGHT
);
gSPEndDisplayList(gfx);
next_x = mFont_SetVertexRectangle(game, x, y, w, h, scale_x, scale_y, mode);
}
}
return next_x;
}
extern void mFont_gppSetRectMode(Gfx** gfx_pp) {
static Gfx disp[] = {
gsDPPipeSync(),
gsSPTexture(0x8000, 0x8000, 0, G_TX_RENDERTILE, G_ON),
gsSPClearGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
gsDPSetTextureLOD(G_TL_TILE),
gsDPSetTextureConvert(G_TC_FILT),
gsDPSetTextureLUT(G_TT_NONE),
gsDPSetTextureFilter(G_TF_BILERP),
gsDPSetCycleType(G_CYC_1CYCLE),
gsDPSetTexturePersp(G_TP_NONE),
gsDPSetCombineMode(mFont_CC_FONT, mFont_CC_FONT),
gsDPSetRenderMode(G_RM_AA_DEC_LINE, G_RM_AA_DEC_LINE2),
gsDPSetPrimColor(0, 0, 255, 255, 255, 255),
gsSPEndDisplayList(),
};
gSPDisplayList((*gfx_pp)++, disp);
}
Reference in New Issue View Git Blame Copy Permalink