Merge branch 'Rainchus:main' into main
This commit is contained in:
CreateSource
GitHub
commit
8f1d6b9680
35 changed files with 4400 additions and 994 deletions
15
src/REL/bootDll/nintendo_data.c
Normal file
15
src/REL/bootDll/nintendo_data.c
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
#include "common.h"
|
||||
|
||||
#include "logoNintendoData.inc"
|
||||
|
||||
void *logoReadNintendo(void)
|
||||
{
|
||||
u32 *src = (u32 *)logoNintendoData;
|
||||
u32 size = *src++;
|
||||
void *dst = HuMemDirectMalloc(HEAP_DATA, size);
|
||||
int decode_type = *src++;
|
||||
if(dst) {
|
||||
HuDecodeData(src, dst, size, decode_type);
|
||||
}
|
||||
return dst;
|
||||
}
|
||||
12
src/REL/safDll/safDll.c
Normal file
12
src/REL/safDll/safDll.c
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
#include "common.h"
|
||||
#include "REL/executor.h"
|
||||
|
||||
void fn_1_0(void) {
|
||||
|
||||
}
|
||||
|
||||
//fn_1_4
|
||||
// https://decomp.me/scratch/Ii0sV
|
||||
|
||||
// fn_1_288
|
||||
// https://decomp.me/scratch/VQ3CT
|
||||
|
|
@ -97,7 +97,7 @@ static void SubchrMain()
|
|||
WipeCreate(2, 0, -1);
|
||||
HuPrcSleep(wipeData.duration+1.0f);
|
||||
fn_80035A0C();
|
||||
omOvlGotoEx(41, 1, 0, 0);
|
||||
omOvlGotoEx(OVL_M433, 1, 0, 0);
|
||||
do {
|
||||
HuPrcVSleep();
|
||||
} while(1);
|
||||
|
|
|
|||
746
src/REL/w10Dll/w10Dll.c
Normal file
746
src/REL/w10Dll/w10Dll.c
Normal file
|
|
@ -0,0 +1,746 @@
|
|||
#include "common.h"
|
||||
#include "REL/executor.h"
|
||||
|
||||
s16 HuWinCreate(float x, float y, s16 w, s16 h, s16 frame);
|
||||
|
||||
typedef struct unkw10Dll {
|
||||
char unk0[0x0C];
|
||||
Vec3f unk0C;
|
||||
Vec3f unk18;
|
||||
s32 unk24;
|
||||
} unkw10Dll; //sizeof 0x28
|
||||
|
||||
typedef struct w10DllUnk01 {
|
||||
u8 unk0;
|
||||
f32 unk4;
|
||||
f32 unk8;
|
||||
f32 unkC;
|
||||
f32 unk10;
|
||||
} w10DllUnk01; //sizeof ?
|
||||
|
||||
typedef struct w10DllUnk02 {
|
||||
char unk00[0x5C];
|
||||
w10DllUnk01* unk5C;
|
||||
} w10DllUnk02; //sizeof ?
|
||||
|
||||
//this belongs to m456Dll
|
||||
w10DllUnk02** fn_8002FAC0(Process*, s32);
|
||||
void fn_8003FD10(s16, f32, f32);
|
||||
extern s16 lbl_1_bss_20;
|
||||
extern f32 lbl_1_rodata_5C;
|
||||
extern f32 lbl_1_rodata_60;
|
||||
s16 fn_8003F958(s32, s32, s32);
|
||||
void fn_8003FBEC(s16);
|
||||
void fn_8008853C(s32);
|
||||
extern s32 lbl_801A52E8;
|
||||
void fn_800B42B4(s32);
|
||||
void fn_80082AAC(s32);
|
||||
void fn_800B4264(s32, s32, s32);
|
||||
void fn_1_1FB0(void);
|
||||
void fn_1_1E3C(s32, s32, s32);
|
||||
void fn_8007500C(s32);
|
||||
void fn_1_BA0(s32);
|
||||
void fn_8006F0D4(s32, f32);
|
||||
f32 fn_8006F128(s32);
|
||||
f64 fmod(f32, f64);
|
||||
void fn_1_C20(void);
|
||||
void fn_8006F61C(s16, s32);
|
||||
void fn_800B42BC(s16);
|
||||
void fn_80023828(s32, s32);
|
||||
s32 fn_8006DBD4(s16);
|
||||
void fn_8005B150(void*, void*);
|
||||
void fn_1_6D8(void);
|
||||
void fn_1_E0(void);
|
||||
void fn_8006F2E8(s32, Vec3f*);
|
||||
void HuWinMesSet(s16, s32);
|
||||
void fn_1_1D68(void);
|
||||
void fn_1_1DEC(void);
|
||||
void fn_1_AEC(void);
|
||||
void fn_80042848(s16);
|
||||
void fn_80045BF4(s16, s32);
|
||||
void fn_80045D7C(s16, s32, s32, s32, s32);
|
||||
void fn_80045E84(s16, s32);
|
||||
void fn_80046F04(s32, f32*, ...);
|
||||
void fn_8005D10C(void*, void*);
|
||||
s16 fn_8006D9A4(s32, void*, s32);
|
||||
void fn_8006DB90(s16);
|
||||
void fn_8006DDE8(s16, f32);
|
||||
void fn_8006E2B8(s16, s32, s32);
|
||||
void fn_8006E878(s16, f32);
|
||||
void fn_8006F158(s16, void*);
|
||||
void fn_8006F1A8(s16, f32, f32, f32);
|
||||
s32 fn_8006F220(s16 arg0, Vec3f* arg1);
|
||||
void fn_8006F50C(s16, s32);
|
||||
void fn_80073FF4(void*);
|
||||
void fn_80073FFC(void*);
|
||||
void fn_80074004(void*);
|
||||
s32 fn_800745F0(s32, s32);
|
||||
void fn_800772EC(s32);
|
||||
void fn_80077A3C(void);
|
||||
void fn_80077AAC(s16);
|
||||
void fn_8007A83C(s16);
|
||||
void fn_80083EDC(s16);
|
||||
void fn_800A4F6C(s16);
|
||||
void fn_800B3FD8(void*);
|
||||
void fn_800B4274(s32, s32);
|
||||
void fn_1_1AAC(void);
|
||||
void fn_1_8C0(void);
|
||||
void fn_1_904(void);
|
||||
void fn_1_908(void);
|
||||
s32 fn_1_90C(void);
|
||||
void fn_1_91C(void);
|
||||
void Hu3D2Dto3D(Vec3f*, s32, Vec3f*);
|
||||
void fn_8005D5C0(Vec3f*);
|
||||
void fn_8006F338(s16, f32, f32, f32);
|
||||
s32 fn_8005B6A8(void);
|
||||
void fn_8006EFBC(s16, Mtx);
|
||||
void fn_8006F270(s16, f32, f32, f32);
|
||||
void fn_8003FB08(s16);
|
||||
extern Vec3f lbl_1_data_80[];
|
||||
extern f32 lbl_1_rodata_38;
|
||||
extern f32 lbl_1_rodata_3C;
|
||||
extern f32 lbl_1_rodata_40;
|
||||
extern Process* lbl_1_bss_18;
|
||||
extern s16 lbl_1_bss_1C;
|
||||
extern s16 lbl_1_bss_1E;
|
||||
extern s32 lbl_1_data_78; //no idea on the type of this
|
||||
extern f64 lbl_1_rodata_28;
|
||||
extern f32 lbl_1_rodata_30;
|
||||
extern f32 lbl_1_rodata_34;
|
||||
extern BoardStateSubStruct* lbl_1_bss_0;
|
||||
extern s16 lbl_1_bss_10[12]; //could be incorrect size
|
||||
extern void* lbl_1_bss_8; //unknown type
|
||||
extern s16 lbl_1_bss_C;
|
||||
extern s16 lbl_1_bss_E;
|
||||
extern unkw10Dll lbl_1_data_0[1];
|
||||
extern s16 lbl_1_bss_22[11];
|
||||
extern s32 lbl_1_data_2A8[11];
|
||||
extern s16 lbl_1_data_28;
|
||||
extern s16 lbl_1_data_2A;
|
||||
extern s16 lbl_1_data_2C;
|
||||
extern s16 lbl_1_data_2E;
|
||||
extern s16 lbl_1_data_30;
|
||||
extern s16 lbl_1_data_32;
|
||||
extern s32 lbl_1_data_54; //unknown type
|
||||
extern s32 lbl_1_data_5C; //unknown type
|
||||
extern s32 lbl_1_data_64; //unknown type
|
||||
extern s32 lbl_1_data_6C; //unknown type
|
||||
extern f32 lbl_1_rodata_10;
|
||||
extern f32 lbl_1_rodata_14;
|
||||
extern f32 lbl_1_rodata_18;
|
||||
extern f32 lbl_1_rodata_1C;
|
||||
extern BoardState lbl_8018FCF8;
|
||||
|
||||
/*
|
||||
void fn_1_0(void) {
|
||||
fn_8005B150(&fn_1_E0, &fn_1_6D8);
|
||||
}
|
||||
*/
|
||||
|
||||
// function is probably global. only inlined in rels?
|
||||
/*
|
||||
inline s32 get_current_board(void) {
|
||||
return lbl_8018FCF8.unk08 & 0x1F;
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_E0(void) {
|
||||
f32 sp10;
|
||||
f32 spC;
|
||||
s32 sp8;
|
||||
|
||||
s32 i;
|
||||
unkw10Dll* temp_r30;
|
||||
s32 temp;
|
||||
s32 temp2;
|
||||
|
||||
temp2 = get_current_board();
|
||||
lbl_1_bss_0 = &lbl_8018FCF8.unk10;
|
||||
lbl_1_bss_0->unk0 = 0;
|
||||
lbl_1_bss_0->unk4 = 0;
|
||||
lbl_1_bss_0->unk6 = 0;
|
||||
fn_800B3FD8(&fn_1_1AAC);
|
||||
fn_1_AEC();
|
||||
fn_1_1D68();
|
||||
lbl_1_bss_C = 0;
|
||||
fn_800772EC(0x7B0000);
|
||||
temp = fn_800745F0(0, 1);
|
||||
fn_800B4274(temp, 1);
|
||||
lbl_1_data_28 = fn_8006D9A4(0x7B0001, NULL, 0);
|
||||
fn_8006DDE8(lbl_1_data_28, lbl_1_rodata_10);
|
||||
fn_8006F1A8(lbl_1_data_28, lbl_1_rodata_14, lbl_1_rodata_14, lbl_1_rodata_14);
|
||||
fn_8006E2B8(lbl_1_data_28, 0, 0x40000001);
|
||||
fn_8006E878(lbl_1_data_28, lbl_1_rodata_18);
|
||||
lbl_1_data_2A = fn_8006D9A4(0x7B0002, NULL, 0);
|
||||
fn_8006DDE8(lbl_1_data_2A, lbl_1_rodata_10);
|
||||
fn_8006F1A8(lbl_1_data_2A, lbl_1_rodata_14, lbl_1_rodata_14, lbl_1_rodata_14);
|
||||
fn_8006E2B8(lbl_1_data_2A, 0, 0x40000001);
|
||||
lbl_1_data_2C = fn_8006D9A4(0x7B0011, &lbl_1_data_54, 0);
|
||||
fn_8006F1A8(lbl_1_data_2C, lbl_1_rodata_14, lbl_1_rodata_14, lbl_1_rodata_14);
|
||||
fn_8006E2B8(lbl_1_data_2C, 1, 0x40000001);
|
||||
lbl_1_data_2E = fn_8006D9A4(0x20005, &lbl_1_data_5C, 0);
|
||||
fn_8006E2B8(lbl_1_data_2E, 1, 0x40000001);
|
||||
lbl_1_data_32 = fn_8006D9A4(0x20012, &lbl_1_data_64, 0);
|
||||
fn_8006E2B8(lbl_1_data_32, 1, 0x40000001);
|
||||
lbl_1_data_30 = fn_8006D9A4(0x2000D, &lbl_1_data_6C, 0);
|
||||
fn_8006E2B8(lbl_1_data_30, 1, 0x40000001);
|
||||
fn_8005D10C(&fn_1_8C0, &fn_1_904);
|
||||
for (i = 0; i < 1; i++) {
|
||||
temp_r30 = &lbl_1_data_0[i];
|
||||
if (temp_r30->unk24 != -1) {
|
||||
lbl_1_bss_8 = NULL;
|
||||
lbl_1_bss_10[i] = fn_8006D9A4(temp_r30->unk24, lbl_1_bss_8, 0);
|
||||
fn_8006F158(lbl_1_bss_10[i], temp_r30);
|
||||
fn_8006F220(lbl_1_bss_10[i], &temp_r30->unk0C);
|
||||
fn_8006F2E8(lbl_1_bss_10[i], &temp_r30->unk18);
|
||||
fn_8006F50C(lbl_1_bss_10[i], 1);
|
||||
if (lbl_1_bss_8 != NULL) {
|
||||
fn_8006E2B8(lbl_1_bss_10[i], 0, 0x40000001);
|
||||
}
|
||||
}
|
||||
}
|
||||
fn_8006F50C(lbl_1_bss_10[0], 0);
|
||||
lbl_1_bss_0->unk8 = fn_8006D9A4(0x7000A, NULL, 0);
|
||||
fn_8006F50C(lbl_1_bss_0->unk8, 0);
|
||||
fn_80073FF4(&fn_1_90C);
|
||||
fn_80073FFC(&fn_1_91C);
|
||||
fn_80074004(&fn_1_908);
|
||||
fn_80083EDC(lbl_1_data_2C);
|
||||
fn_800A4F6C(lbl_1_data_32);
|
||||
fn_80077AAC(lbl_1_data_2E);
|
||||
fn_8007A83C(lbl_1_data_30);
|
||||
fn_80046F04(1, &spC, 0x2E003A);
|
||||
lbl_1_bss_E = HuWinCreate(lbl_1_rodata_1C, lbl_1_rodata_20, spC, sp10, 1);
|
||||
HuWinMesSet(lbl_1_bss_E, 0x2E003A);
|
||||
fn_80045E84(lbl_1_bss_E, 0);
|
||||
fn_80045BF4(lbl_1_bss_E, 1);
|
||||
fn_80045D7C(lbl_1_bss_E, 7, 0, 0, 0);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_6D8(void) {
|
||||
s32 i;
|
||||
for (i = 0; i < 1; i++) {
|
||||
if (lbl_1_bss_10[i] != 0) {
|
||||
fn_8006DB90(lbl_1_bss_10[i]);
|
||||
lbl_1_bss_10[i] = 0;
|
||||
}
|
||||
}
|
||||
if (lbl_1_data_32 != -1) {
|
||||
fn_8006DB90(lbl_1_data_32);
|
||||
lbl_1_data_32 = -1;
|
||||
}
|
||||
if (lbl_1_data_2E != -1) {
|
||||
fn_8006DB90(lbl_1_data_2E);
|
||||
lbl_1_data_2E = -1;
|
||||
}
|
||||
if (lbl_1_data_30 != -1) {
|
||||
fn_8006DB90(lbl_1_data_30);
|
||||
lbl_1_data_30 = -1;
|
||||
}
|
||||
if (lbl_1_data_2C != -1) {
|
||||
fn_8006DB90(lbl_1_data_2C);
|
||||
lbl_1_data_2C = -1;
|
||||
}
|
||||
if (lbl_1_data_28 != -1) {
|
||||
fn_8006DB90(lbl_1_data_28);
|
||||
lbl_1_data_28 = -1;
|
||||
}
|
||||
if (lbl_1_data_2A != -1) {
|
||||
fn_8006DB90(lbl_1_data_2A);
|
||||
lbl_1_data_2A = -1;
|
||||
}
|
||||
fn_8006DB90(lbl_1_bss_0->unk8);
|
||||
fn_1_1DEC();
|
||||
fn_80042848(lbl_1_bss_E);
|
||||
fn_80077A3C();
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_8C0(void) {
|
||||
s32 temp = fn_8006DBD4(lbl_1_data_28);
|
||||
fn_80023828(temp, 1);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_904(void) {
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_908(void) {
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
s32 fn_1_90C(void) {
|
||||
return 0;
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_914(void) {
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_918(void) {
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_91C(void) {
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
s32 fn_1_920(s32 arg0, f32 arg8, f32 arg9) {
|
||||
s32 var_r31;
|
||||
f32 var_f29;
|
||||
f32 var_f31;
|
||||
|
||||
var_r31 = 0;
|
||||
var_f31 = fn_8006F128(arg0);
|
||||
arg8 = fmod(arg8, lbl_1_rodata_28);
|
||||
if (var_f31 < lbl_1_rodata_14) {
|
||||
var_f31 += lbl_1_rodata_30;
|
||||
}
|
||||
if (arg8 < lbl_1_rodata_14) {
|
||||
arg8 += lbl_1_rodata_30;
|
||||
}
|
||||
if (var_f31 != arg8) {
|
||||
var_f29 = arg8 - var_f31;
|
||||
if (var_f29 < lbl_1_rodata_14) {
|
||||
var_f29 += lbl_1_rodata_30;
|
||||
}
|
||||
if (var_f29 < lbl_1_rodata_34) {
|
||||
if (var_f29 > arg9) {
|
||||
var_f31 = var_f31 + arg9;
|
||||
} else {
|
||||
var_f31 = arg8;
|
||||
}
|
||||
} else if ((lbl_1_rodata_30 - var_f29) > arg9) {
|
||||
var_f31 = var_f31 - arg9;
|
||||
} else {
|
||||
var_f31 = arg8;
|
||||
}
|
||||
if (var_f31 < lbl_1_rodata_14) {
|
||||
var_f31 += lbl_1_rodata_30;
|
||||
}
|
||||
if (var_f31 >= lbl_1_rodata_30) {
|
||||
var_f31 -= lbl_1_rodata_30;
|
||||
}
|
||||
fn_8006F0D4(arg0, var_f31);
|
||||
} else {
|
||||
var_r31 = 1;
|
||||
}
|
||||
return var_r31;
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_AEC(void) {
|
||||
lbl_1_bss_1C = 0;
|
||||
lbl_1_bss_1E = fn_8006D9A4(0x7B000F, &lbl_1_data_78, 0);
|
||||
fn_8006E2B8(lbl_1_bss_1E, 1, 0x40000001);
|
||||
fn_800B42BC(lbl_1_bss_1E);
|
||||
fn_8006F61C(lbl_1_bss_1E, 6);
|
||||
lbl_1_bss_18 = HuPrcCreate(fn_1_C20, 0x1FFF, 0x1800, 0);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_BA0(s32 arg0) {
|
||||
s32 var_r31;
|
||||
|
||||
switch (lbl_1_bss_1C) {
|
||||
case 0:
|
||||
var_r31 = 5;
|
||||
break;
|
||||
case 1:
|
||||
var_r31 = 6;
|
||||
break;
|
||||
}
|
||||
BoardMessCreate(var_r31, arg0, -1);
|
||||
BoardMessWait();
|
||||
BoardMessKill();
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_C10(void) {
|
||||
HuPrcEnd();
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_C20(void) {
|
||||
Mtx sp20;
|
||||
Vec3f sp14;
|
||||
Vec3f sp8;
|
||||
|
||||
while (1) {
|
||||
if (fn_8005B6A8() != 0) {
|
||||
fn_8006DB90(lbl_1_bss_1E);
|
||||
fn_800B42BC(-1);
|
||||
HuPrcEnd();
|
||||
}
|
||||
Hu3D2Dto3D(&lbl_1_data_80[lbl_1_bss_1C], 1, &sp14);
|
||||
fn_8006F158(lbl_1_bss_1E, &sp14);
|
||||
fn_8005D5C0(&sp8);
|
||||
PSMTXRotRad(sp20, 'y', lbl_1_rodata_38);
|
||||
fn_8006EFBC(lbl_1_bss_1E, sp20);
|
||||
fn_8006F270(lbl_1_bss_1E, sp8.x, lbl_1_rodata_3C, lbl_1_rodata_3C);
|
||||
fn_8006F338(lbl_1_bss_1E, lbl_1_rodata_40, lbl_1_rodata_40, lbl_1_rodata_40);
|
||||
HuPrcVSleep();
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_D2C(void) {
|
||||
fn_1_BA0(0x2E0001);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_D54(void) {
|
||||
fn_1_BA0(0x2E0002);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_D7C(void) {
|
||||
fn_1_BA0(0x2E0003);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_DA4(void) {
|
||||
fn_1_BA0(0x2E0004);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_DCC(void) {
|
||||
fn_1_BA0(0x2E0005);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_DF4(void) {
|
||||
fn_1_BA0(0x2E0006);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_E1C(void) {
|
||||
fn_1_BA0(0x2E0007);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_E44(void) {
|
||||
fn_1_BA0(0x2E0008);
|
||||
fn_1_BA0(0x2E0009);
|
||||
fn_8007500C(0);
|
||||
fn_8006F50C(lbl_1_data_2C, 1);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_E94(void) {
|
||||
fn_1_BA0(0x2E000A);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_EBC(void) {
|
||||
fn_1_BA0(0x2E000B);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_EE4(void) {
|
||||
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_EE8(void) {
|
||||
fn_1_1E3C(0, 0x122, 0x8C);
|
||||
fn_1_BA0(0x2E000C);
|
||||
fn_1_BA0(0x2E000D);
|
||||
fn_1_1FB0();
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_F30(void) {
|
||||
fn_1_1E3C(1, 0x122, 0x8C);
|
||||
fn_1_BA0(0x2E000E);
|
||||
fn_1_1FB0();
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_F6C(void) {
|
||||
fn_1_1E3C(2, 0x122, 0x8C);
|
||||
fn_1_BA0(0x2E000F);
|
||||
fn_1_1FB0();
|
||||
fn_800B4264(0, 0x50, 1);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_FB8(void) {
|
||||
fn_1_1E3C(3, 0x122, 0x8C);
|
||||
fn_1_BA0(0x2E0010);
|
||||
fn_1_1FB0();
|
||||
fn_1_BA0(0x2E0011);
|
||||
fn_800B4264(-0x50, 0, 1);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_1010(void) {
|
||||
fn_1_1E3C(4, 0x122, 0x8C);
|
||||
fn_1_BA0(0x2E0012);
|
||||
fn_1_1FB0();
|
||||
fn_800B4264(0, 0x50, 1);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_105C(void) {
|
||||
fn_1_1E3C(5, 0x122, 0x8C);
|
||||
fn_1_BA0(0x2E0013);
|
||||
fn_1_1FB0();
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_1098(void) {
|
||||
fn_1_BA0(0x2E0014);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_10C0(void) {
|
||||
fn_1_BA0(0x2E0015);
|
||||
fn_800B4264(-0x50, 0, 1);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_10F8(void) {
|
||||
fn_1_1E3C(6, 0x122, 0x8C);
|
||||
fn_1_BA0(0x2E0016);
|
||||
fn_1_1FB0();
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_1134(void) {
|
||||
fn_1_1E3C(7, 0x122, 0x8C);
|
||||
fn_1_BA0(0x2E0017);
|
||||
fn_1_1FB0();
|
||||
fn_80082AAC(1);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_1178(void) {
|
||||
fn_1_BA0(0x2E0018);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_11A0(void) {
|
||||
s32 temp;
|
||||
|
||||
fn_1_BA0(0x2E0019);
|
||||
temp = fn_800745F0(0, 1);
|
||||
fn_800B4274(temp, 0);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_11EC(void) {
|
||||
s32 temp;
|
||||
|
||||
fn_1_BA0(0x2E001A);
|
||||
temp = fn_800745F0(0, 1);
|
||||
fn_800B4274(temp, 0);
|
||||
fn_800B42B4(0);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_1240(void) {
|
||||
fn_1_BA0(0x2E001B);
|
||||
fn_800B4264(0x50, 0, 1);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_1278(void) {
|
||||
fn_1_BA0(0x2E001C);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_12A0(void) {
|
||||
fn_1_BA0(0x2E001D);
|
||||
fn_80062B74(2, 1);
|
||||
fn_800B42B4(1);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_12DC(void) {
|
||||
fn_1_BA0(0x2E001E);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_1304(void) {
|
||||
fn_1_BA0(0x2E001F);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_132C(void) {
|
||||
fn_1_BA0(0x2E0020);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_1354(void) {
|
||||
fn_1_BA0(0x2E0021);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_137C(void) {
|
||||
fn_1_BA0(0x2E0022);
|
||||
}
|
||||
*/
|
||||
|
||||
// fn_1_13A4
|
||||
|
||||
/*
|
||||
void fn_1_176C(void) {
|
||||
fn_1_C10(1);
|
||||
fn_1_BA0(0x2E0024);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_179C(void) {
|
||||
fn_1_BA0(0x2E0025);
|
||||
gPlayerData[1].flags.unk0 = 2;
|
||||
gPlayerData[3].flags.unk0 = 2;
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_17F4(void) {
|
||||
fn_1_BA0(0x2E0026);
|
||||
gPlayerData[0].flags.unk0 = 2;
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_1834(void) {
|
||||
fn_1_BA0(0x2E0027);
|
||||
gPlayerData[0].flags.unk0 = 1;
|
||||
gPlayerData[1].flags.unk0 = 1;
|
||||
gPlayerData[2].flags.unk0 = 1;
|
||||
gPlayerData[3].flags.unk0 = 2;
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_18BC(void) {
|
||||
fn_1_BA0(0x2E0028);
|
||||
fn_1_BA0(0x2E0029);
|
||||
lbl_801A52E8 = 0;
|
||||
fn_8008853C(0);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_1908(void) {
|
||||
fn_1_BA0(0x2E002D);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_1930(void) {
|
||||
fn_1_BA0(0x2E002F);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_1958(void) {
|
||||
fn_1_BA0(0x2E0031);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_1980(void) {
|
||||
|
||||
}
|
||||
*/
|
||||
|
||||
// fn_1_1984
|
||||
|
||||
// fn_1_1AAC
|
||||
|
||||
/*
|
||||
void fn_1_1D68(void) {
|
||||
s32 temp_r4;
|
||||
s32 temp_r5;
|
||||
s32 i;
|
||||
|
||||
for (i = 0; i < 11; i++) {
|
||||
lbl_1_bss_22[i] = fn_8003F958(lbl_1_data_2A8[i], 0, 0);
|
||||
fn_8003FBEC(lbl_1_bss_22[i]);
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void fn_1_1DEC(void) {
|
||||
s32 i;
|
||||
|
||||
for (i = 0; i < 11; i++) {
|
||||
fn_8003FB08(lbl_1_bss_22[i]);
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
// fn_1_1E3C
|
||||
|
||||
/*
|
||||
void fn_1_1FB0(void) {
|
||||
f32 var_f31;
|
||||
f32 var_f30;
|
||||
u32 i;
|
||||
|
||||
var_f31 = lbl_1_rodata_60;
|
||||
var_f30 = lbl_1_rodata_60;
|
||||
for (i = 0; i < 15; i++) {
|
||||
var_f31 -= lbl_1_rodata_5C;
|
||||
var_f30 -= lbl_1_rodata_5C;
|
||||
fn_8003FD10(lbl_1_bss_20, var_f31, var_f30);
|
||||
HuPrcVSleep();
|
||||
}
|
||||
fn_8003FBEC(lbl_1_bss_20);
|
||||
}
|
||||
*/
|
||||
552
src/game/data.c
Normal file
552
src/game/data.c
Normal file
|
|
@ -0,0 +1,552 @@
|
|||
#include "common.h"
|
||||
#include "dolphin/dvd.h"
|
||||
|
||||
#define PTR_OFFSET(ptr, offset) (void *)(((u8 *)(ptr)+(u32)(offset)))
|
||||
#define DATA_EFF_SIZE(size) (((size)+1) & ~0x1)
|
||||
|
||||
static void **HuDataReadMultiSub(s32 *data_ids, BOOL use_num, s32 num);
|
||||
|
||||
#define DATA_MAX_READSTAT 128
|
||||
|
||||
#define DATADIR_DEFINE(name, path) { path, -1 },
|
||||
|
||||
static FileListEntry DataDirStat[DATADIR_COUNT+1] = {
|
||||
#include "datadir_table.h"
|
||||
{ NULL, -1 }
|
||||
};
|
||||
|
||||
#undef DATADIR_DEFINE
|
||||
|
||||
u32 DirDataSize;
|
||||
static u32 DataDirMax;
|
||||
static s32 shortAccessSleep;
|
||||
static DataReadStat ReadDataStat[DATA_MAX_READSTAT];
|
||||
|
||||
void HuDataInit(void)
|
||||
{
|
||||
int i = 0;
|
||||
FileListEntry *dir_stat = DataDirStat;
|
||||
DataReadStat *read_stat;
|
||||
while(dir_stat->name) {
|
||||
if((dir_stat->file_id = DVDConvertPathToEntrynum(dir_stat->name)) == -1) {
|
||||
OSReport("data.c: Data File Error(%s)\n", dir_stat->name);
|
||||
OSPanic("data.c", 65, "\n");
|
||||
}
|
||||
i++;
|
||||
dir_stat++;
|
||||
}
|
||||
DataDirMax = i;
|
||||
for(i=0, read_stat = ReadDataStat; i<DATA_MAX_READSTAT; i++, read_stat++) {
|
||||
read_stat->dir_id = -1;
|
||||
read_stat->used = FALSE;
|
||||
read_stat->status = 0;
|
||||
}
|
||||
}
|
||||
|
||||
static int HuDataReadStatusGet(void)
|
||||
{
|
||||
int i;
|
||||
for(i=0; i<DATA_MAX_READSTAT; i++) {
|
||||
if(ReadDataStat[i].dir_id == -1) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(i >= DATA_MAX_READSTAT) {
|
||||
i = -1;
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
int HuDataReadChk(s32 data_num)
|
||||
{
|
||||
int i;
|
||||
data_num >>= 16;
|
||||
for(i=0; i<DATA_MAX_READSTAT; i++) {
|
||||
if(ReadDataStat[i].dir_id == data_num && ReadDataStat[i].status != 1) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(i >= DATA_MAX_READSTAT) {
|
||||
i = -1;
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
DataReadStat *HuDataGetStatus(void *dir_ptr)
|
||||
{
|
||||
int i;
|
||||
for(i=0; i<DATA_MAX_READSTAT; i++) {
|
||||
if(ReadDataStat[i].dir == dir_ptr) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(i > DATA_MAX_READSTAT) {
|
||||
return NULL;
|
||||
}
|
||||
return &ReadDataStat[i];
|
||||
}
|
||||
|
||||
void *HuDataGetDirPtr(s32 data_num)
|
||||
{
|
||||
int status = HuDataReadChk(data_num);
|
||||
if(status < 0) {
|
||||
return NULL;
|
||||
}
|
||||
return ReadDataStat[status].dir;
|
||||
}
|
||||
|
||||
DataReadStat *HuDataDirRead(s32 data_num)
|
||||
{
|
||||
DataReadStat *read_stat;
|
||||
int status;
|
||||
s32 dir_id;
|
||||
dir_id = data_num >> 16;
|
||||
if(DataDirMax <= dir_id) {
|
||||
OSReport("data.c: Data Number Error(%d)\n", data_num);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if((status = HuDataReadChk(data_num)) < 0) {
|
||||
void *dir_aram;
|
||||
if(dir_aram = HuARDirCheck(data_num)) {
|
||||
HuAR_ARAMtoMRAM(dir_aram);
|
||||
while(HuARDMACheck());
|
||||
status = HuDataReadChk(data_num);
|
||||
read_stat = &ReadDataStat[status];
|
||||
} else {
|
||||
status = HuDataReadStatusGet();
|
||||
if(status == -1) {
|
||||
OSReport("data.c: Data Work Max Error\n");
|
||||
return NULL;
|
||||
}
|
||||
read_stat = &ReadDataStat[status];
|
||||
read_stat->dir = HuDvdDataFastRead(DataDirStat[dir_id].file_id);
|
||||
if(read_stat->dir) {
|
||||
read_stat->dir_id = dir_id;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
read_stat = &ReadDataStat[status];
|
||||
}
|
||||
return read_stat;
|
||||
}
|
||||
|
||||
DataReadStat *HuDataDirReadNum(s32 data_num, s32 num)
|
||||
{
|
||||
DataReadStat *read_stat;
|
||||
int status;
|
||||
s32 dir_id;
|
||||
dir_id = data_num >> 16;
|
||||
if(DataDirMax <= dir_id) {
|
||||
OSReport("data.c: Data Number Error(%d)\n", data_num);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if((status = HuDataReadChk(data_num)) < 0) {
|
||||
void *dir_aram;
|
||||
if((dir_aram = HuARDirCheck(data_num))) {
|
||||
OSReport("ARAM data num %x\n", data_num);
|
||||
HuAR_ARAMtoMRAMNum(dir_aram, num);
|
||||
while(HuARDMACheck());
|
||||
status = HuDataReadChk(data_num);
|
||||
read_stat = &ReadDataStat[status];
|
||||
read_stat->used = TRUE;
|
||||
read_stat->num = num;
|
||||
} else {
|
||||
OSReport("data num %x\n", data_num);
|
||||
status = HuDataReadStatusGet();
|
||||
if(status == -1) {
|
||||
OSReport("data.c: Data Work Max Error\n");
|
||||
return NULL;
|
||||
}
|
||||
read_stat = &ReadDataStat[status];
|
||||
read_stat->dir = HuDvdDataFastReadNum(DataDirStat[dir_id].file_id, num);
|
||||
if(read_stat->dir) {
|
||||
read_stat->dir_id = dir_id;
|
||||
read_stat->used = TRUE;
|
||||
read_stat->num = num;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
read_stat = &ReadDataStat[status];
|
||||
}
|
||||
return read_stat;
|
||||
}
|
||||
|
||||
DataReadStat *HuDataDirSet(void *dir_ptr, s32 data_num)
|
||||
{
|
||||
DataReadStat *read_stat = HuDataGetStatus(dir_ptr);
|
||||
int status;
|
||||
if((status = HuDataReadChk(read_stat->dir_id << 16)) >= 0) {
|
||||
HuDataDirClose(data_num);
|
||||
}
|
||||
if((status = HuDataReadStatusGet()) == -1) {
|
||||
OSReport("data.c: Data Work Max Error\n");
|
||||
return NULL;
|
||||
} else {
|
||||
read_stat = &ReadDataStat[status];
|
||||
read_stat->dir = dir_ptr;
|
||||
read_stat->dir_id = data_num >>16;
|
||||
return read_stat;
|
||||
}
|
||||
}
|
||||
|
||||
void HuDataDirReadAsyncCallBack(s32 result, DVDFileInfo* fileInfo)
|
||||
{
|
||||
DataReadStat *read_stat;
|
||||
int i;
|
||||
for(i=0; i<DATA_MAX_READSTAT; i++) {
|
||||
if(ReadDataStat[i].status == 1 && ReadDataStat[i].file_info.startAddr == fileInfo->startAddr) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(i >= DATA_MAX_READSTAT) {
|
||||
OSPanic("data.c", 358, "dvd.c AsyncCallBack Error");
|
||||
}
|
||||
read_stat = &ReadDataStat[i];
|
||||
read_stat->status = 0;
|
||||
DVDClose(&read_stat->file_info);
|
||||
}
|
||||
|
||||
s32 HuDataDirReadAsync(s32 data_num)
|
||||
{
|
||||
DataReadStat *read_stat;
|
||||
int status;
|
||||
s32 dir_id;
|
||||
dir_id = data_num >> 16;
|
||||
if(DataDirMax <= dir_id) {
|
||||
OSReport("data.c: Data Number Error(%d)\n", data_num);
|
||||
return -1;
|
||||
}
|
||||
if((status = HuDataReadChk(data_num)) < 0) {
|
||||
void *dir_aram;
|
||||
if(dir_aram = HuARDirCheck(data_num)) {
|
||||
OSReport("ARAM data num %x\n", data_num);
|
||||
HuAR_ARAMtoMRAM(dir_aram);
|
||||
status = 0x10000;
|
||||
} else {
|
||||
status = HuDataReadStatusGet();
|
||||
if(status == -1) {
|
||||
OSReport("data.c: Data Work Max Error\n");
|
||||
return -1;
|
||||
}
|
||||
read_stat = &ReadDataStat[status];
|
||||
read_stat->status = 1;
|
||||
read_stat->dir_id = dir_id;
|
||||
read_stat->dir = HuDvdDataFastReadAsync(DataDirStat[dir_id].file_id, read_stat);
|
||||
}
|
||||
} else {
|
||||
status = -1;
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
s32 HuDataDirReadNumAsync(s32 data_num, s32 num)
|
||||
{
|
||||
DataReadStat *read_stat;
|
||||
int status;
|
||||
s32 dir_id;
|
||||
dir_id = data_num >> 16;
|
||||
if(DataDirMax <= dir_id) {
|
||||
OSReport("data.c: Data Number Error(%d)\n", data_num);
|
||||
return -1;
|
||||
}
|
||||
if((status = HuDataReadChk(data_num)) < 0) {
|
||||
if((status = HuDataReadStatusGet()) == -1) {
|
||||
OSReport("data.c: Data Work Max Error\n");
|
||||
return -1;
|
||||
}
|
||||
ReadDataStat[status].status = TRUE;
|
||||
ReadDataStat[status].dir_id = dir_id;
|
||||
read_stat = &ReadDataStat[status];
|
||||
read_stat->used = TRUE;
|
||||
read_stat->num = num;
|
||||
read_stat->dir = HuDvdDataFastReadAsync(DataDirStat[dir_id].file_id, read_stat);
|
||||
} else {
|
||||
status = -1;
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
BOOL HuDataGetAsyncStat(s32 status)
|
||||
{
|
||||
if(status == 0x10000) {
|
||||
return HuARDMACheck() == 0;
|
||||
} else {
|
||||
return ReadDataStat[status].status == 0;
|
||||
}
|
||||
}
|
||||
|
||||
static void GetFileInfo(DataReadStat *read_stat, s32 file_num)
|
||||
{
|
||||
u32 *temp_ptr;
|
||||
temp_ptr = (u32 *)PTR_OFFSET(read_stat->dir, (file_num * 4))+1;
|
||||
read_stat->file = PTR_OFFSET(read_stat->dir, *temp_ptr);
|
||||
temp_ptr = read_stat->file;
|
||||
read_stat->raw_len = *temp_ptr++;
|
||||
read_stat->comp_type = *temp_ptr++;
|
||||
read_stat->file = temp_ptr;
|
||||
}
|
||||
|
||||
void *HuDataRead(s32 data_num)
|
||||
{
|
||||
DataReadStat *read_stat;
|
||||
int status;
|
||||
void *buf;
|
||||
if(!HuDataDirRead(data_num)) {
|
||||
(void)data_num;
|
||||
return NULL;
|
||||
}
|
||||
if((status = HuDataReadChk(data_num)) == -1) {
|
||||
return NULL;
|
||||
}
|
||||
read_stat = &ReadDataStat[status];
|
||||
GetFileInfo(read_stat, data_num & 0xFFFF);
|
||||
buf = HuMemDirectMalloc(0, DATA_EFF_SIZE(read_stat->raw_len));
|
||||
if(buf) {
|
||||
HuDecodeData(read_stat->file, buf, read_stat->raw_len, read_stat->comp_type);
|
||||
}
|
||||
return buf;
|
||||
}
|
||||
|
||||
void *HuDataReadNum(s32 data_num, s32 num)
|
||||
{
|
||||
DataReadStat *read_stat;
|
||||
int status;
|
||||
void *buf;
|
||||
if(!HuDataDirReadNum(data_num, num)) {
|
||||
return NULL;
|
||||
}
|
||||
if((status = HuDataReadChk(data_num)) == -1) {
|
||||
return NULL;
|
||||
}
|
||||
read_stat = &ReadDataStat[status];
|
||||
GetFileInfo(read_stat, data_num & 0xFFFF);
|
||||
buf = HuMemDirectMallocNum(0, DATA_EFF_SIZE(read_stat->raw_len), num);
|
||||
if(buf) {
|
||||
HuDecodeData(read_stat->file, buf, read_stat->raw_len, read_stat->comp_type);
|
||||
}
|
||||
return buf;
|
||||
}
|
||||
|
||||
void *HuDataSelHeapRead(s32 data_num, HeapID heap)
|
||||
{
|
||||
DataReadStat *read_stat;
|
||||
int status;
|
||||
void *buf;
|
||||
if(!HuDataDirRead(data_num)) {
|
||||
return NULL;
|
||||
}
|
||||
if((status = HuDataReadChk(data_num)) == -1) {
|
||||
return NULL;
|
||||
}
|
||||
read_stat = &ReadDataStat[status];
|
||||
GetFileInfo(read_stat, data_num & 0xFFFF);
|
||||
switch(heap) {
|
||||
case HEAP_MUSIC:
|
||||
buf = HuMemDirectMalloc(HEAP_MUSIC, DATA_EFF_SIZE(read_stat->raw_len));
|
||||
break;
|
||||
|
||||
case HEAP_DATA:
|
||||
buf = HuMemDirectMalloc(HEAP_DATA, DATA_EFF_SIZE(read_stat->raw_len));
|
||||
break;
|
||||
|
||||
case HEAP_DVD:
|
||||
buf = HuMemDirectMalloc(HEAP_DVD, DATA_EFF_SIZE(read_stat->raw_len));
|
||||
break;
|
||||
|
||||
default:
|
||||
buf = HuMemDirectMalloc(HEAP_SYSTEM, DATA_EFF_SIZE(read_stat->raw_len));
|
||||
break;
|
||||
}
|
||||
if(buf) {
|
||||
HuDecodeData(read_stat->file, buf, read_stat->raw_len, read_stat->comp_type);
|
||||
}
|
||||
return buf;
|
||||
}
|
||||
|
||||
void *HuDataSelHeapReadNum(s32 data_num, s32 num, HeapID heap)
|
||||
{
|
||||
DataReadStat *read_stat;
|
||||
int status;
|
||||
void *buf;
|
||||
if(!HuDataDirReadNum(data_num, num)) {
|
||||
return NULL;
|
||||
}
|
||||
if((status = HuDataReadChk(data_num)) == -1) {
|
||||
return NULL;
|
||||
}
|
||||
read_stat = &ReadDataStat[status];
|
||||
GetFileInfo(read_stat, data_num & 0xFFFF);
|
||||
switch(heap) {
|
||||
case HEAP_MUSIC:
|
||||
buf = HuMemDirectMalloc(HEAP_MUSIC, DATA_EFF_SIZE(read_stat->raw_len));
|
||||
break;
|
||||
|
||||
case HEAP_DATA:
|
||||
buf = HuMemDirectMallocNum(HEAP_DATA, DATA_EFF_SIZE(read_stat->raw_len), num);
|
||||
break;
|
||||
|
||||
case HEAP_DVD:
|
||||
buf = HuMemDirectMallocNum(HEAP_DVD, DATA_EFF_SIZE(read_stat->raw_len), num);
|
||||
break;
|
||||
|
||||
default:
|
||||
buf = HuMemDirectMallocNum(HEAP_SYSTEM, DATA_EFF_SIZE(read_stat->raw_len), num);
|
||||
break;
|
||||
}
|
||||
if(buf) {
|
||||
HuDecodeData(read_stat->file, buf, read_stat->raw_len, read_stat->comp_type);
|
||||
}
|
||||
return buf;
|
||||
}
|
||||
|
||||
void **HuDataReadMulti(s32 *data_ids)
|
||||
{
|
||||
return HuDataReadMultiSub(data_ids, FALSE, 0);
|
||||
}
|
||||
|
||||
static void **HuDataReadMultiSub(s32 *data_ids, BOOL use_num, s32 num)
|
||||
{
|
||||
s32 *dir_ids;
|
||||
char **paths;
|
||||
void **dir_ptrs;
|
||||
void **out_ptrs;
|
||||
int i, count, total_files;
|
||||
u32 dir_id;
|
||||
for(i=0, count=0; data_ids[i] != -1; i++) {
|
||||
dir_id = data_ids[i] >> 16;
|
||||
if(DataDirMax <= dir_id) {
|
||||
OSReport("data.c: Data Number Error(%d)\n", data_ids[i]);
|
||||
return NULL;
|
||||
}
|
||||
if(HuDataReadChk(data_ids[i]) < 0) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
total_files = i;
|
||||
dir_ids = HuMemDirectMalloc(HEAP_SYSTEM, (count+1)*sizeof(s32));
|
||||
for(i=0; i<count+1; i++) {
|
||||
dir_ids[i] = -1;
|
||||
}
|
||||
paths = HuMemDirectMalloc(HEAP_SYSTEM, (count+1)*sizeof(char *));
|
||||
for(i=0, count=0; data_ids[i] != -1; i++) {
|
||||
dir_id = data_ids[i] >> 16;
|
||||
if(HuDataReadChk(data_ids[i]) < 0) {
|
||||
int j;
|
||||
for(j=0; dir_ids[j] != -1; j++) {
|
||||
if(dir_ids[j] == dir_id){
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(dir_ids[j] == -1) {
|
||||
dir_ids[j] = dir_id;
|
||||
paths[count++] = DataDirStat[dir_id].name;
|
||||
}
|
||||
}
|
||||
}
|
||||
dir_ptrs = HuDvdDataReadMulti(paths);
|
||||
for(i=0; dir_ids[i] != -1; i++) {
|
||||
s32 status;
|
||||
if((status = HuDataReadStatusGet()) == -1) {
|
||||
OSReport("data.c: Data Work Max Error\n");
|
||||
(void)count; //HACK to match HuDataReadMultiSub
|
||||
HuMemDirectFree(dir_ids);
|
||||
HuMemDirectFree(paths);
|
||||
return NULL;
|
||||
} else {
|
||||
ReadDataStat[status].dir = dir_ptrs[i];
|
||||
ReadDataStat[status].dir_id = dir_ids[i];
|
||||
}
|
||||
}
|
||||
HuMemDirectFree(dir_ids);
|
||||
HuMemDirectFree(paths);
|
||||
HuMemDirectFree(dir_ptrs);
|
||||
if(use_num) {
|
||||
out_ptrs = HuMemDirectMallocNum(HEAP_SYSTEM, (total_files+1)*sizeof(void *), num);
|
||||
} else {
|
||||
out_ptrs = HuMemDirectMalloc(HEAP_SYSTEM, (total_files+1)*sizeof(void *));
|
||||
}
|
||||
for(i=0; data_ids[i] != -1; i++) {
|
||||
if(use_num) {
|
||||
out_ptrs[i] = HuDataReadNum(data_ids[i], num);
|
||||
} else {
|
||||
out_ptrs[i] = HuDataRead(data_ids[i]);
|
||||
}
|
||||
}
|
||||
out_ptrs[i] = NULL;
|
||||
return out_ptrs;
|
||||
}
|
||||
|
||||
s32 HuDataGetSize(s32 data_num)
|
||||
{
|
||||
DataReadStat *read_stat;
|
||||
int status;
|
||||
if((status = HuDataReadChk(data_num)) == -1) {
|
||||
return -1;
|
||||
}
|
||||
read_stat = &ReadDataStat[status];
|
||||
GetFileInfo(read_stat, data_num & 0xFFFF);
|
||||
return DATA_EFF_SIZE(read_stat->raw_len);
|
||||
}
|
||||
|
||||
void HuDataClose(void *ptr)
|
||||
{
|
||||
if(ptr) {
|
||||
HuMemDirectFree(ptr);
|
||||
}
|
||||
}
|
||||
|
||||
void HuDataCloseMulti(void **ptrs)
|
||||
{
|
||||
int i;
|
||||
for(i=0; ptrs[i]; i++) {
|
||||
void *ptr = ptrs[i];
|
||||
if(ptr) {
|
||||
HuMemDirectFree(ptr);
|
||||
}
|
||||
}
|
||||
if(ptrs) {
|
||||
HuMemDirectFree(ptrs);
|
||||
}
|
||||
}
|
||||
|
||||
void HuDataDirClose(s32 data_id)
|
||||
{
|
||||
DataReadStat *read_stat;
|
||||
int i;
|
||||
s32 dir_id = data_id >> 16;
|
||||
for(i=0; i<DATA_MAX_READSTAT; i++) {
|
||||
if(ReadDataStat[i].dir_id == dir_id) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(i >= DATA_MAX_READSTAT) {
|
||||
return;
|
||||
}
|
||||
read_stat = &ReadDataStat[i];
|
||||
if(read_stat->status == 1) {
|
||||
OSPanic("data.c", 812, "data.c: Async Close Error\n");
|
||||
}
|
||||
read_stat->dir_id = -1;
|
||||
HuDvdDataClose(read_stat->dir);
|
||||
read_stat->dir = NULL;
|
||||
read_stat->used = FALSE;
|
||||
read_stat->status = 0;
|
||||
}
|
||||
|
||||
void HuDataDirCloseNum(s32 num)
|
||||
{
|
||||
int i;
|
||||
for(i=0; i<DATA_MAX_READSTAT; i++) {
|
||||
if(ReadDataStat[i].used == TRUE && ReadDataStat[i].num == num) {
|
||||
HuDataDirClose(ReadDataStat[i].dir_id << 16);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//Still to be decompiled
|
||||
void *HuDataReadNumHeapShortForce(s32 data_id, s32 num, HeapID heap)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
188
src/game/dvd.c
Normal file
188
src/game/dvd.c
Normal file
|
|
@ -0,0 +1,188 @@
|
|||
#include "common.h"
|
||||
#include "dolphin/dvd.h"
|
||||
#include "dolphin/os.h"
|
||||
|
||||
|
||||
static DVDDiskID correctDiskID = {
|
||||
{ 'M', 'P', 'G', 'C' }, //gameName
|
||||
{ 'H', 'U' }, //company
|
||||
1, //diskNumber
|
||||
1, //gameVersion
|
||||
1, //streaming
|
||||
0, //streamingBufSize
|
||||
};
|
||||
|
||||
|
||||
static int CallBackStatus;
|
||||
static s32 beforeDvdStatus;
|
||||
|
||||
static void HuDVDReadAsyncCallBack(s32 result, DVDFileInfo* fileInfo)
|
||||
{
|
||||
CallBackStatus = 1;
|
||||
}
|
||||
|
||||
static void *HuDvdDataReadWait(DVDFileInfo *file, int heap, int mode, int num, DVDCallback cb, BOOL skip_wait)
|
||||
{
|
||||
u32 len;
|
||||
void *buf;
|
||||
if(mode != 0 && mode != 1 && mode != 2) {
|
||||
OSReport("dvd.c: HuDvdDataReadWait Mode Error");
|
||||
buf = NULL;
|
||||
len = 0;
|
||||
}
|
||||
len = file->length;
|
||||
DirDataSize = len;
|
||||
if(mode == 1) {
|
||||
buf = HuMemDirectMallocNum(heap, OSRoundUp32B(len), num);
|
||||
} else {
|
||||
buf = HuMemDirectMalloc(heap, OSRoundUp32B(len));
|
||||
}
|
||||
if(!buf) {
|
||||
OSReport("dvd.c: Memory Allocation Error (Length %x) (mode %d)\n", len, mode);
|
||||
OSReport("Rest Memory %x\n", HuMemHeapSizeGet(3)-HuMemUsedMallocSizeGet(3));
|
||||
OSPanic("dvd.c", 75, "\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
DCInvalidateRange(buf, OSRoundUp32B(len));
|
||||
OSReport("Rest Memory %x\n", HuMemHeapSizeGet(3)-HuMemUsedMallocSizeGet(3));
|
||||
CallBackStatus = 0;
|
||||
DVDReadAsync(file, buf, OSRoundUp32B(len), 0, cb);
|
||||
if(!skip_wait) {
|
||||
while(!CallBackStatus) {
|
||||
HuDvdErrorWatch();
|
||||
}
|
||||
HuDvdErrorWatch();
|
||||
}
|
||||
|
||||
return buf;
|
||||
}
|
||||
|
||||
void *HuDvdDataRead(char *path)
|
||||
{
|
||||
DVDFileInfo file;
|
||||
void *data = NULL;
|
||||
if(!DVDOpen(path, &file)) {
|
||||
OSPanic("dvd.c", 146, "dvd.c: File Open Error");
|
||||
} else {
|
||||
data = HuDvdDataReadWait(&file, HEAP_DVD, 0, 0, HuDVDReadAsyncCallBack, FALSE);
|
||||
DVDClose(&file);
|
||||
}
|
||||
return data;
|
||||
}
|
||||
|
||||
void **HuDvdDataReadMulti(char **paths)
|
||||
{
|
||||
DVDFileInfo file;
|
||||
int i;
|
||||
u32 count;
|
||||
void **file_ptrs;
|
||||
count = 0;
|
||||
while(paths[count]) {
|
||||
count++;
|
||||
}
|
||||
file_ptrs = HuMemDirectMalloc(0, count*sizeof(void *));
|
||||
for(i=0; i<count; i++) {
|
||||
if(!DVDOpen(paths[i], &file)) {
|
||||
OSPanic("dvd.c", 183, "dvd.c: File Open Error");
|
||||
return NULL;
|
||||
} else {
|
||||
file_ptrs[i] = HuDvdDataReadWait(&file, HEAP_DVD, 0, 0, HuDVDReadAsyncCallBack, FALSE);
|
||||
DVDClose(&file);
|
||||
}
|
||||
}
|
||||
return file_ptrs;
|
||||
}
|
||||
|
||||
void *HuDvdDataReadDirect(char *path, HeapID heap)
|
||||
{
|
||||
DVDFileInfo file;
|
||||
void *data = NULL;
|
||||
if(!DVDOpen(path, &file)) {
|
||||
OSPanic("dvd.c", 202, "dvd.c: File Open Error");
|
||||
} else {
|
||||
data = HuDvdDataReadWait(&file, heap, 2, 0, HuDVDReadAsyncCallBack, FALSE);
|
||||
DVDClose(&file);
|
||||
}
|
||||
return data;
|
||||
}
|
||||
|
||||
void *HuDvdDataFastRead(s32 entrynum)
|
||||
{
|
||||
DVDFileInfo file;
|
||||
void *data = NULL;
|
||||
if(!DVDFastOpen(entrynum, &file)) {
|
||||
OSPanic("dvd.c", 243, "dvd.c: File Open Error");
|
||||
} else {
|
||||
data = HuDvdDataReadWait(&file, HEAP_DVD, 0, 0, HuDVDReadAsyncCallBack, FALSE);
|
||||
DVDClose(&file);
|
||||
}
|
||||
return data;
|
||||
}
|
||||
|
||||
void *HuDvdDataFastReadNum(s32 entrynum, s32 num)
|
||||
{
|
||||
DVDFileInfo file;
|
||||
void *data = NULL;
|
||||
if(!DVDFastOpen(entrynum, &file)) {
|
||||
(void)num;
|
||||
OSPanic("dvd.c", 258, "dvd.c: File Open Error");
|
||||
} else {
|
||||
data = HuDvdDataReadWait(&file, HEAP_DVD, 1, num, HuDVDReadAsyncCallBack, FALSE);
|
||||
DVDClose(&file);
|
||||
}
|
||||
return data;
|
||||
}
|
||||
|
||||
void *HuDvdDataFastReadAsync(s32 entrynum, DataReadStat *stat)
|
||||
{
|
||||
DVDFileInfo file;
|
||||
void *data = NULL;
|
||||
if(!DVDFastOpen(entrynum, &stat->file_info)) {
|
||||
OSPanic("dvd.c", 274, "dvd.c: File Open Error");
|
||||
} else {
|
||||
data = HuDvdDataReadWait(&stat->file_info, HEAP_DVD, 0, 0, HuDataDirReadAsyncCallBack, TRUE);
|
||||
}
|
||||
return data;
|
||||
}
|
||||
|
||||
void HuDvdDataClose(void *ptr)
|
||||
{
|
||||
if(ptr) {
|
||||
HuMemDirectFree(ptr);
|
||||
}
|
||||
}
|
||||
|
||||
void HuDvdErrorWatch()
|
||||
{
|
||||
int status = DVDGetDriveStatus();
|
||||
if(status == beforeDvdStatus) {
|
||||
return;
|
||||
}
|
||||
beforeDvdStatus = status;
|
||||
switch(status+1) {
|
||||
case 0:
|
||||
OSReport("DVD ERROR:Fatal error occurred\n***HALT***");
|
||||
while(1);
|
||||
break;
|
||||
|
||||
case 5:
|
||||
OSReport("DVD ERROR:No disk\n");
|
||||
break;
|
||||
|
||||
case 6:
|
||||
OSReport("DVD ERROR:Cover open\n");
|
||||
break;
|
||||
|
||||
case 7:
|
||||
OSReport("DVD ERROR:Wrong disk\n");
|
||||
break;
|
||||
|
||||
case 12:
|
||||
OSReport("DVD ERROR:Please retry\n");
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
1
src/game/font.c
Normal file
1
src/game/font.c
Normal file
|
|
@ -0,0 +1 @@
|
|||
#include "ank8x8_4b.inc"
|
||||
274
src/game/init.c
Normal file
274
src/game/init.c
Normal file
|
|
@ -0,0 +1,274 @@
|
|||
#include "common.h"
|
||||
#include "dolphin/os.h"
|
||||
#include "dolphin/gx.h"
|
||||
#include "dolphin/dvd.h"
|
||||
#include "dolphin/vi.h"
|
||||
#include "dolphin/pad.h"
|
||||
|
||||
struct memory_info {
|
||||
void *start;
|
||||
void *end;
|
||||
};
|
||||
|
||||
extern void HuAudInit();
|
||||
extern void HuCardInit();
|
||||
extern void HuARInit();
|
||||
extern u32 frand();
|
||||
extern void HuFaultInitXfbDirectDraw(GXRenderModeObj *mode);
|
||||
extern void HuFaultSetXfbAddress(int fb, void *addr);
|
||||
|
||||
static GXRenderModeObj rmodeobj;
|
||||
|
||||
static BOOL FirstFrame = TRUE;
|
||||
GXRenderModeObj *RenderMode;
|
||||
OSHeapHandle currentHeapHandle;
|
||||
static void *DefaultFifo;
|
||||
static GXFifoObj *DefaultFifoObj;
|
||||
void *DemoFrameBuffer1;
|
||||
void *DemoFrameBuffer2;
|
||||
void *DemoCurrentBuffer;
|
||||
u32 minimumVcount;
|
||||
float minimumVcountf;
|
||||
u32 worstVcount;
|
||||
static BOOL DemoStatEnable;
|
||||
|
||||
|
||||
static void InitRenderMode(GXRenderModeObj *mode);
|
||||
static void InitMem();
|
||||
static void InitGX();
|
||||
static void InitVI();
|
||||
static void SwapBuffers();
|
||||
static void LoadMemInfo();
|
||||
|
||||
void HuSysInit(GXRenderModeObj *mode)
|
||||
{
|
||||
u32 rnd_temp;
|
||||
OSInit();
|
||||
DVDInit();
|
||||
VIInit();
|
||||
PADInit();
|
||||
if(OSGetProgressiveMode() == 1 && VIGetDTVStatus() == 1) {
|
||||
mode = &GXNtsc480Prog;
|
||||
}
|
||||
InitRenderMode(mode);
|
||||
InitMem();
|
||||
VIConfigure(RenderMode);
|
||||
VIConfigurePan(0, 0, 640, 480);
|
||||
DefaultFifo = OSAlloc(0x100000);
|
||||
DefaultFifoObj = GXInit(DefaultFifo, 0x100000);
|
||||
InitGX();
|
||||
InitVI();
|
||||
HuFaultInitXfbDirectDraw(RenderMode);
|
||||
HuFaultSetXfbAddress(0, DemoFrameBuffer1);
|
||||
HuFaultSetXfbAddress(1, DemoFrameBuffer2);
|
||||
HuDvdErrDispInit(RenderMode, DemoFrameBuffer1, DemoFrameBuffer2);
|
||||
rnd_temp = frand();
|
||||
HuMemInitAll();
|
||||
HuAudInit();
|
||||
HuARInit();
|
||||
minimumVcount = minimumVcountf = 1.0f;
|
||||
worstVcount = 0;
|
||||
OSInitFastCast();
|
||||
HuCardInit();
|
||||
}
|
||||
|
||||
static void InitRenderMode(GXRenderModeObj *mode)
|
||||
{
|
||||
if(mode != NULL) {
|
||||
RenderMode = mode;
|
||||
return;
|
||||
}
|
||||
switch(VIGetTvFormat()) {
|
||||
case 0:
|
||||
RenderMode = &GXNtsc480IntDf;
|
||||
break;
|
||||
|
||||
case 1:
|
||||
RenderMode = &GXPal528IntDf;
|
||||
break;
|
||||
|
||||
case 2:
|
||||
RenderMode = &GXMpal480IntDf;
|
||||
break;
|
||||
|
||||
default:
|
||||
OSPanic("init.c", 169, "DEMOInit: invalid TV format\n");
|
||||
break;
|
||||
}
|
||||
GXAdjustForOverscan(RenderMode, &rmodeobj, 0, 16);
|
||||
RenderMode = &rmodeobj;
|
||||
}
|
||||
|
||||
static void InitGX()
|
||||
{
|
||||
GXSetViewport(0, 0, RenderMode->fbWidth, RenderMode->xfbHeight, 0, 1);
|
||||
GXSetScissor(0, 0, RenderMode->fbWidth, RenderMode->efbHeight);
|
||||
GXSetDispCopySrc(0, 0, RenderMode->fbWidth, RenderMode->efbHeight);
|
||||
GXSetDispCopyDst(RenderMode->fbWidth, RenderMode->xfbHeight);
|
||||
GXSetDispCopyYScale((float)RenderMode->xfbHeight/(float)RenderMode->efbHeight);
|
||||
GXSetCopyFilter(RenderMode->aa, RenderMode->sample_pattern, GX_TRUE, RenderMode->vfilter);
|
||||
if(RenderMode->aa) {
|
||||
GXSetPixelFmt(GX_PF_RGB565_Z16, GX_ZC_LINEAR);
|
||||
} else {
|
||||
GXSetPixelFmt(GX_PF_RGB8_Z24, GX_ZC_LINEAR);
|
||||
}
|
||||
GXCopyDisp(DemoCurrentBuffer, GX_TRUE);
|
||||
GXSetDispCopyGamma(GX_GM_1_0);
|
||||
}
|
||||
|
||||
static void InitMem()
|
||||
{
|
||||
void *arena_lo = OSGetArenaLo();
|
||||
void *arena_hi = OSGetArenaHi();
|
||||
u32 fb_size = (u16)(((u16)RenderMode->fbWidth+15) & ~15)*RenderMode->xfbHeight*2;
|
||||
DemoFrameBuffer1 = (void *)OSRoundUp32B((u32)arena_lo);
|
||||
DemoFrameBuffer2 = (void *)OSRoundUp32B((u32)DemoFrameBuffer1+fb_size);
|
||||
DemoCurrentBuffer = DemoFrameBuffer2;
|
||||
arena_lo = (void *)OSRoundUp32B((u32)DemoFrameBuffer2+fb_size);
|
||||
OSSetArenaLo(arena_lo);
|
||||
if(OSGetConsoleType() == OS_CONSOLE_DEVHW1 && OSGetPhysicalMemSize() != 0x400000 && OSGetConsoleSimulatedMemSize() < 0x1800000) {
|
||||
LoadMemInfo();
|
||||
} else {
|
||||
arena_lo = OSGetArenaLo();
|
||||
arena_hi = OSGetArenaHi();
|
||||
arena_lo = OSInitAlloc(arena_lo, arena_hi, 1);
|
||||
OSSetArenaLo(arena_lo);
|
||||
arena_lo = (void *)OSRoundUp32B((u32)arena_lo);
|
||||
arena_hi = (void *)OSRoundDown32B((u32)arena_hi);
|
||||
OSSetCurrentHeap(currentHeapHandle = OSCreateHeap(arena_lo, arena_hi));
|
||||
arena_lo = arena_hi;
|
||||
OSSetArenaLo(arena_lo);
|
||||
}
|
||||
}
|
||||
|
||||
static void InitVI()
|
||||
{
|
||||
u32 interlace;
|
||||
VISetNextFrameBuffer(DemoFrameBuffer1);
|
||||
DemoCurrentBuffer = DemoFrameBuffer2;
|
||||
VIFlush();
|
||||
VIWaitForRetrace();
|
||||
interlace = RenderMode->viTVmode & 0x1;
|
||||
if(interlace) {
|
||||
VIWaitForRetrace();
|
||||
}
|
||||
}
|
||||
|
||||
void HuSysBeforeRender()
|
||||
{
|
||||
if(RenderMode->field_rendering) {
|
||||
GXSetViewportJitter(0, 0, RenderMode->fbWidth, RenderMode->xfbHeight, 0, 1, VIGetNextField());
|
||||
} else {
|
||||
GXSetViewport(0, 0, RenderMode->fbWidth, RenderMode->xfbHeight, 0, 1);
|
||||
}
|
||||
GXInvalidateVtxCache();
|
||||
GXInvalidateTexAll();
|
||||
}
|
||||
|
||||
void HuSysDoneRender(s32 retrace_count)
|
||||
{
|
||||
int retrace_dist;
|
||||
if(DemoStatEnable) {
|
||||
GXDrawDone();
|
||||
DEMOUpdateStats(1);
|
||||
DEMOPrintStats();
|
||||
GXDrawDone();
|
||||
DEMOUpdateStats(0);
|
||||
}
|
||||
GXSetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE);
|
||||
GXSetColorUpdate(GX_TRUE);
|
||||
GXDrawDone();
|
||||
GXCopyDisp(DemoCurrentBuffer, GX_TRUE);
|
||||
if(minimumVcount != 0) {
|
||||
retrace_dist = VIGetRetraceCount()-retrace_count;
|
||||
if(worstVcount < retrace_dist) {
|
||||
worstVcount = retrace_dist;
|
||||
}
|
||||
while(VIGetRetraceCount()-retrace_count < minimumVcount-1) {
|
||||
VIWaitForRetrace();
|
||||
}
|
||||
}
|
||||
SwapBuffers();
|
||||
}
|
||||
|
||||
static void SwapBuffers()
|
||||
{
|
||||
VISetNextFrameBuffer(DemoCurrentBuffer);
|
||||
if(FirstFrame) {
|
||||
VISetBlack(GX_FALSE);
|
||||
FirstFrame = FALSE;
|
||||
}
|
||||
VIFlush();
|
||||
VIWaitForRetrace();
|
||||
if(DemoCurrentBuffer == DemoFrameBuffer1) {
|
||||
DemoCurrentBuffer = DemoFrameBuffer2;
|
||||
} else {
|
||||
DemoCurrentBuffer = DemoFrameBuffer1;
|
||||
}
|
||||
}
|
||||
|
||||
static void LoadMemInfo()
|
||||
{
|
||||
u32 size;
|
||||
u32 copy_size;
|
||||
u32 offset;
|
||||
u32 entries;
|
||||
u32 i;
|
||||
void *arena_lo;
|
||||
void *arena_hi;
|
||||
void *alloc_max;
|
||||
void *alloc_min;
|
||||
|
||||
struct memory_info *buf_ptr;
|
||||
DVDFileInfo file;
|
||||
char buf[240];
|
||||
|
||||
OSReport("\nNow, try to find memory info file...\n\n");
|
||||
if(!DVDOpen("/meminfo.bin", &file)) {
|
||||
OSReport("\nCan't find memory info file. Use /XXX toolname/ to maximize available\n");
|
||||
OSReport("memory space. For now, we only use the first %dMB.\n", (OSGetConsoleSimulatedMemSize()/1024)/1024);
|
||||
arena_lo = OSGetArenaLo();
|
||||
arena_hi = OSGetArenaHi();
|
||||
arena_lo = OSInitAlloc(arena_lo, arena_hi, 1);
|
||||
OSSetArenaLo(arena_lo);
|
||||
arena_lo = (void *)OSRoundUp32B((u32)arena_lo);
|
||||
arena_hi = (void *)OSRoundDown32B((u32)arena_hi);
|
||||
OSSetCurrentHeap(OSCreateHeap(arena_lo, arena_hi));
|
||||
arena_lo = arena_hi;
|
||||
OSSetArenaLo(arena_lo);
|
||||
} else {
|
||||
buf_ptr = (struct memory_info *)OSRoundUp32B((u32)buf);
|
||||
alloc_max = OSGetArenaHi();
|
||||
alloc_min = (void *)(OSGetConsoleSimulatedMemSize()+0x80000000);
|
||||
OSSetArenaHi((void *)(OSGetPhysicalMemSize()+0x80000000));
|
||||
arena_lo = OSGetArenaLo();
|
||||
arena_hi = OSGetArenaHi();
|
||||
arena_lo = OSInitAlloc(arena_lo, arena_hi, 1);
|
||||
OSSetArenaLo(arena_lo);
|
||||
arena_lo = (void *)OSRoundUp32B((u32)arena_lo);
|
||||
arena_hi = (void *)OSRoundDown32B((u32)arena_hi);
|
||||
OSSetCurrentHeap(OSCreateHeap(arena_lo, arena_hi));
|
||||
arena_lo = arena_hi;
|
||||
OSSetArenaLo(arena_lo);
|
||||
OSAllocFixed(&alloc_max, &alloc_min);
|
||||
size = file.length;
|
||||
offset = 0;
|
||||
while(size) {
|
||||
OSReport("loop\n");
|
||||
copy_size = (size < 32) ? size : 32;
|
||||
if(DVDRead(&file, buf_ptr, OSRoundUp32B(copy_size), offset) < 0) {
|
||||
OSPanic("init.c", 576, "An error occurred when issuing read to /meminfo.bin\n");
|
||||
}
|
||||
entries = copy_size/sizeof(struct memory_info);
|
||||
for(i=0; i<entries; i++) {
|
||||
OSReport("start: 0x%08x, end: 0x%08x\n", buf_ptr[i].start, buf_ptr[i].end);
|
||||
OSAllocFixed(&buf_ptr[i].start, &buf_ptr[i].end);
|
||||
OSReport("Removed 0x%08x - 0x%08x from the current heap\n", buf_ptr[i].start, (u32)buf_ptr[i].end-1);
|
||||
}
|
||||
size -= copy_size;
|
||||
offset += copy_size;
|
||||
}
|
||||
DVDClose(&file);
|
||||
OSDumpHeap(__OSCurrHeap);
|
||||
}
|
||||
}
|
||||
|
|
@ -1,8 +1,8 @@
|
|||
#include "common.h"
|
||||
#include "dolphin/os.h"
|
||||
|
||||
static u32 HeapSizeTbl[5] = { 0x240000, 0x140000, 0xA80000, 0x580000, 0 };
|
||||
static void *HeapTbl[5];
|
||||
static u32 HeapSizeTbl[HEAP_MAX] = { 0x240000, 0x140000, 0xA80000, 0x580000, 0 };
|
||||
static void *HeapTbl[HEAP_MAX];
|
||||
|
||||
void HuMemInitAll(void)
|
||||
{
|
||||
|
|
@ -10,7 +10,7 @@ void HuMemInitAll(void)
|
|||
void *ptr;
|
||||
u32 free_size;
|
||||
for(i=0; i<4; i++) {
|
||||
ptr = OSAllocFromHeap(__OSCurrHeap, HeapSizeTbl[i]);
|
||||
ptr = OSAlloc(HeapSizeTbl[i]);
|
||||
if(ptr == NULL) {
|
||||
OSReport("HuMem> Failed OSAlloc Size:%d\n", HeapSizeTbl[i]);
|
||||
return;
|
||||
|
|
@ -19,7 +19,7 @@ void HuMemInitAll(void)
|
|||
}
|
||||
free_size = OSCheckHeap(currentHeapHandle);
|
||||
OSReport("HuMem> left memory space %dKB(%d)\n", free_size/1024, free_size);
|
||||
ptr = OSAllocFromHeap(__OSCurrHeap, free_size);
|
||||
ptr = OSAlloc(free_size);
|
||||
if(ptr == NULL) {
|
||||
OSReport("HuMem> Failed OSAlloc left space\n");
|
||||
return;
|
||||
|
|
@ -39,12 +39,12 @@ void HuMemDCFlushAll()
|
|||
HuMemDCFlush(0);
|
||||
}
|
||||
|
||||
void HuMemDCFlush(int heap)
|
||||
void HuMemDCFlush(HeapID heap)
|
||||
{
|
||||
DCFlushRangeNoSync(HeapTbl[heap], HeapSizeTbl[heap]);
|
||||
}
|
||||
|
||||
void *HuMemDirectMalloc(int heap, s32 size)
|
||||
void *HuMemDirectMalloc(HeapID heap, s32 size)
|
||||
{
|
||||
register u32 retaddr;
|
||||
asm {
|
||||
|
|
@ -54,7 +54,7 @@ void *HuMemDirectMalloc(int heap, s32 size)
|
|||
return HuMemMemoryAlloc(HeapTbl[heap], size, retaddr);
|
||||
}
|
||||
|
||||
void *HuMemDirectMallocNum(int heap, s32 size, u32 num)
|
||||
void *HuMemDirectMallocNum(HeapID heap, s32 size, u32 num)
|
||||
{
|
||||
register u32 retaddr;
|
||||
asm {
|
||||
|
|
@ -73,7 +73,7 @@ void HuMemDirectFree(void *ptr)
|
|||
HuMemMemoryFree(ptr, retaddr);
|
||||
}
|
||||
|
||||
void HuMemDirectFreeNum(int heap, u32 num)
|
||||
void HuMemDirectFreeNum(HeapID heap, u32 num)
|
||||
{
|
||||
register u32 retaddr;
|
||||
asm {
|
||||
|
|
@ -82,22 +82,22 @@ void HuMemDirectFreeNum(int heap, u32 num)
|
|||
HuMemMemoryFreeNum(HeapTbl[heap], num, retaddr);
|
||||
}
|
||||
|
||||
s32 HuMemUsedMallocSizeGet(int heap)
|
||||
s32 HuMemUsedMallocSizeGet(HeapID heap)
|
||||
{
|
||||
return HuMemUsedMemorySizeGet(HeapTbl[heap]);
|
||||
}
|
||||
|
||||
s32 HuMemUsedMallocBlockGet(int heap)
|
||||
s32 HuMemUsedMallocBlockGet(HeapID heap)
|
||||
{
|
||||
return HuMemUsedMemoryBlockGet(HeapTbl[heap]);
|
||||
}
|
||||
|
||||
u32 HuMemHeapSizeGet(int heap)
|
||||
u32 HuMemHeapSizeGet(HeapID heap)
|
||||
{
|
||||
return HeapSizeTbl[heap];
|
||||
}
|
||||
|
||||
void *HuMemHeapPtrGet(int heap)
|
||||
void *HuMemHeapPtrGet(HeapID heap)
|
||||
{
|
||||
return HeapTbl[heap];
|
||||
}
|
||||
563
src/game/objmain.c
Normal file
563
src/game/objmain.c
Normal file
|
|
@ -0,0 +1,563 @@
|
|||
#include "common.h"
|
||||
|
||||
#define OM_OVL_HIS_MAX 16
|
||||
#define OM_MAX_GROUPS 10
|
||||
|
||||
typedef struct om_obj_group {
|
||||
u16 next_idx;
|
||||
u16 max_objs;
|
||||
u16 num_objs;
|
||||
u16 *next;
|
||||
omObjData **obj;
|
||||
} omObjGroup;
|
||||
|
||||
typedef struct om_obj_man {
|
||||
s16 max_objs;
|
||||
s16 num_objs;
|
||||
s16 next_idx;
|
||||
s16 obj_last;
|
||||
s16 obj_first;
|
||||
s16 unkA;
|
||||
omObjData *obj;
|
||||
omObjGroup *group;
|
||||
} omObjMan;
|
||||
|
||||
omObjData *omDBGSysKeyObj;
|
||||
Process *omwatchproc;
|
||||
OverlayID omnextovl;
|
||||
OverlayID omcurovl;
|
||||
int omcurdll;
|
||||
int omovlhisidx;
|
||||
int omovlevtno;
|
||||
int omnextovlevtno;
|
||||
int omovlstat;
|
||||
static int omnextovlstat;
|
||||
char omUPauseFlag;
|
||||
s16 omSysExitReq;
|
||||
s16 omdispinfo;
|
||||
|
||||
static omOvlHisData omovlhis[OM_OVL_HIS_MAX];
|
||||
|
||||
char omSysPauseEnableFlag = TRUE;
|
||||
OverlayID omprevovl = OVL_INVALID;
|
||||
|
||||
static void omWatchOverlayProc(void);
|
||||
static void omInsertObj(Process *objman_process, omObjData *object);
|
||||
|
||||
void omMasterInit(int prio, FileListEntry *ovl_list, int ovl_count, OverlayID start_ovl)
|
||||
{
|
||||
omDLLInit(ovl_list);
|
||||
omwatchproc = HuPrcCreate(omWatchOverlayProc, prio, 8192, 0);
|
||||
HuPrcSetStat(omwatchproc, 12);
|
||||
omcurovl = OVL_INVALID;
|
||||
omovlhisidx = -1;
|
||||
omOvlCallEx(start_ovl, 1, 0, 0);
|
||||
omDBGSysKeyObj = NULL;
|
||||
omSysPauseEnable(TRUE);
|
||||
}
|
||||
|
||||
static void omWatchOverlayProc(void)
|
||||
{
|
||||
while(1) {
|
||||
if(omcurovl == OVL_INVALID) {
|
||||
if(omnextovl >= 0 && fadeStat == 0) {
|
||||
HuPrcSleep(0);
|
||||
OSReport("++++++++++++++++++++ Start New OVL %d (EVT:%d STAT:0x%08x) ++++++++++++++++++\n", omnextovl, omnextovlevtno, omnextovlstat);
|
||||
HuMemHeapDump(HuMemHeapPtrGet(HEAP_SYSTEM), -1);
|
||||
HuMemHeapDump(HuMemHeapPtrGet(HEAP_DATA), -1);
|
||||
HuMemHeapDump(HuMemHeapPtrGet(HEAP_DVD), -1);
|
||||
OSReport("objman>Used Memory Size:%08x\n", HuMemUsedMallocSizeGet(HEAP_SYSTEM));
|
||||
OSReport("objman>Used Memory Cnt:%d\n", HuMemUsedMallocBlockGet(HEAP_SYSTEM));
|
||||
OSReport("objman>Init esp\n");
|
||||
espInit();
|
||||
OSReport("objman>Call objectsetup\n");
|
||||
fn_800338EC(omnextovl);
|
||||
HuAudDllSndGrpSet(omnextovl);
|
||||
omcurovl = omnextovl;
|
||||
omovlevtno = omnextovlevtno;
|
||||
omovlstat = omnextovlstat;
|
||||
omnextovl = OVL_INVALID;
|
||||
if(_CheckFlag(0x1000C)) {
|
||||
fn_8003F3AC();
|
||||
}
|
||||
omSysPauseEnable(TRUE);
|
||||
omcurdll = omDLLStart(omcurovl, 0);
|
||||
OSReport("objman>ObjectSetup end\n");
|
||||
if(omcurovl != OVL_INVALID) {
|
||||
goto watch_child;
|
||||
} else {
|
||||
continue;
|
||||
}
|
||||
} else {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
} else {
|
||||
watch_child:
|
||||
HuPrcChildWatch();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void omOvlCallEx(OverlayID overlay, s16 arg2, int event, int stat)
|
||||
{
|
||||
OSReport("objman>Call New Ovl %d(%d)\n", overlay, arg2);
|
||||
if(omovlhisidx >= OM_OVL_HIS_MAX) {
|
||||
OSReport("objman>OVL Call over error\n");
|
||||
return;
|
||||
}
|
||||
omovlhis[++omovlhisidx].overlay = overlay;
|
||||
omovlhis[omovlhisidx].event = event;
|
||||
omovlhis[omovlhisidx].stat = stat;
|
||||
omOvlGotoEx(overlay, arg2, event, stat);
|
||||
}
|
||||
|
||||
void omOvlGotoEx(OverlayID overlay, s16 arg2, int event, int stat)
|
||||
{
|
||||
omprevovl = omcurovl;
|
||||
if(omcurovl >= 0) {
|
||||
omOvlKill(arg2);
|
||||
}
|
||||
omnextovl = overlay;
|
||||
omnextovlevtno = event;
|
||||
omnextovlstat = stat;
|
||||
}
|
||||
|
||||
void omOvlReturnEx(s16 level, s16 arg2)
|
||||
{
|
||||
omovlhisidx -= level;
|
||||
OSReport("objman>Ovl Return %d=%d(%d)\n", level, omovlhisidx, arg2);
|
||||
if(omovlhisidx < 0) {
|
||||
OSReport("objman>OVL under error\n");
|
||||
omovlhisidx = 0;
|
||||
}
|
||||
omOvlGotoEx(omovlhis[omovlhisidx].overlay, arg2, omovlhis[omovlhisidx].event, omovlhis[omovlhisidx].stat);
|
||||
}
|
||||
|
||||
void omOvlKill(s16 arg)
|
||||
{
|
||||
fn_8004D6F4(-1);
|
||||
fn_80035A0C();
|
||||
Hu3DAllKill();
|
||||
HuWinAllKill();
|
||||
HuSprClose();
|
||||
HuPrcChildKill(omwatchproc);
|
||||
HuMemDirectFreeNum(HEAP_SYSTEM, 0x10000000);
|
||||
HuDataDirCloseNum(0x10000000);
|
||||
HuMemDirectFreeNum(HEAP_DVD, 0x10000000);
|
||||
HuMemDirectFreeNum(HEAP_DATA, 0x10000000);
|
||||
HuPadRumbleAllStop();
|
||||
HuAudFXListnerKill();
|
||||
OSReport("OvlKill %d\n", arg);
|
||||
omSysExitReq = FALSE;
|
||||
omDLLNumEnd(omcurovl, arg);
|
||||
omcurovl = OVL_INVALID;
|
||||
omDBGSysKeyObj = NULL;
|
||||
}
|
||||
|
||||
void omOvlHisChg(s32 level, OverlayID overlay, int event, int stat)
|
||||
{
|
||||
omOvlHisData *history;
|
||||
if(omovlhisidx-level < 0 || omovlhisidx-level >= OM_OVL_HIS_MAX) {
|
||||
OSReport("objman> omOvlHisChg: overlay 実行履歴の範囲外を変更しようとしました\n");
|
||||
return;
|
||||
}
|
||||
history = &omovlhis[omovlhisidx-level];
|
||||
history->overlay = overlay;
|
||||
history->event = event;
|
||||
history->stat = stat;
|
||||
}
|
||||
|
||||
omOvlHisData *omOvlHisGet(s32 level)
|
||||
{
|
||||
if(omovlhisidx-level < 0 || omovlhisidx-level >= OM_OVL_HIS_MAX) {
|
||||
OSReport("objman> omOvlHisGet: overlay 実行履歴の範囲外を参照しようとしました\n");
|
||||
return NULL;
|
||||
}
|
||||
return &omovlhis[omovlhisidx-level];
|
||||
}
|
||||
|
||||
Process *omInitObjMan(s16 max_objs, int prio)
|
||||
{
|
||||
omObjGroup *group_all;
|
||||
omObjData *obj_all;
|
||||
omObjData *obj;
|
||||
int i;
|
||||
omObjMan *objman;
|
||||
Process *process;
|
||||
OSReport("objman>InitObjMan start\n");
|
||||
max_objs += 2;
|
||||
omSysExitReq = FALSE;
|
||||
process = HuPrcChildCreate(omMain, prio, 16384, 0, omwatchproc);
|
||||
HuPrcSetStat(process, 12);
|
||||
objman = HuMemDirectMallocNum(HEAP_SYSTEM, sizeof(omObjMan), 0x10000000);
|
||||
objman->max_objs = max_objs;
|
||||
process->user_data = objman;
|
||||
process->dtor = omDestroyObjMan;
|
||||
objman->num_objs = 0;
|
||||
objman->next_idx = 0;
|
||||
objman->obj_last = -1;
|
||||
objman->obj_first = -1;
|
||||
obj_all = HuMemDirectMallocNum(HEAP_SYSTEM, max_objs*sizeof(omObjData), 0x10000000);
|
||||
objman->obj = obj_all;
|
||||
group_all = HuMemDirectMallocNum(HEAP_SYSTEM, OM_MAX_GROUPS*sizeof(omObjGroup), 0x10000000);
|
||||
objman->group = group_all;
|
||||
for(i=0; i<max_objs;i++) {
|
||||
obj = &obj_all[i];
|
||||
obj->stat = 1;
|
||||
obj->prio = obj->prev =obj->next = -1;
|
||||
obj->unk10 = 0;
|
||||
obj->trans.x = obj->trans.y = obj->trans.z = obj->rot.x = obj->rot.y = obj->rot.z = 0.0f;
|
||||
obj->scale.x = obj->scale.y = obj->scale.z = 1.0f;
|
||||
obj->model = obj->motion = NULL;
|
||||
obj->func = obj->data = NULL;
|
||||
obj->next_idx = i+1;
|
||||
obj->mtncnt = 0;
|
||||
obj->motion = NULL;
|
||||
}
|
||||
for(i=0; i<OM_MAX_GROUPS;i++) {
|
||||
group_all[i].max_objs = 0;
|
||||
group_all[i].num_objs = 0;
|
||||
group_all[i].next_idx = 0;
|
||||
group_all[i].obj = NULL;
|
||||
group_all[i].next = NULL;
|
||||
}
|
||||
OSReport("objman>InitObjMan end\n");
|
||||
omUPauseFlag = FALSE;
|
||||
HuPrcAllUPause(0);
|
||||
return process;
|
||||
}
|
||||
|
||||
void omDestroyObjMan(void)
|
||||
{
|
||||
Process *process = HuPrcCurrentGet();
|
||||
omObjMan *objman = process->user_data;
|
||||
objman->obj_last = -1;
|
||||
OSReport("objman>Destory ObjMan\n");
|
||||
}
|
||||
|
||||
omObjData *omAddObjEx(Process *objman_process, s16 prio, u16 mdlcnt, u16 mtncnt, s16 group, void (*func)(omObjData *))
|
||||
{
|
||||
int i;
|
||||
omObjData *object;
|
||||
s16 next_idx;
|
||||
omObjMan *objman = objman_process->user_data;
|
||||
omObjData *obj_base = objman->obj;
|
||||
if(objman->num_objs == objman->max_objs) {
|
||||
return NULL;
|
||||
}
|
||||
next_idx = objman->next_idx;
|
||||
object = &obj_base[next_idx];
|
||||
object->next_idx_alloc = next_idx;
|
||||
object->prio = prio;
|
||||
omInsertObj(objman_process, object);
|
||||
if(mdlcnt) {
|
||||
object->model = HuMemDirectMallocNum(HEAP_SYSTEM, mdlcnt*sizeof(s16), 0x10000000);
|
||||
object->mdlcnt = mdlcnt;
|
||||
for(i=0; i<mdlcnt; i++) {
|
||||
object->model[i] = -1;
|
||||
}
|
||||
} else {
|
||||
object->model = NULL;
|
||||
object->mdlcnt = 0;
|
||||
}
|
||||
if(mtncnt) {
|
||||
object->motion = HuMemDirectMallocNum(HEAP_SYSTEM, mtncnt*sizeof(s16), 0x10000000);
|
||||
object->mtncnt = mtncnt;
|
||||
} else {
|
||||
object->motion = NULL;
|
||||
object->mtncnt = 0;
|
||||
}
|
||||
if(group >= 0) {
|
||||
omAddMember(objman_process, group, object);
|
||||
} else {
|
||||
object->group = group;
|
||||
object->group_idx = 0;
|
||||
}
|
||||
object->stat = 4;
|
||||
object->unk10 = 0;
|
||||
object->func = func;
|
||||
object->work[0] = object->work[1] = object->work[2] = object->work[3] = 0;
|
||||
objman->next_idx = object->next_idx;
|
||||
objman->num_objs++;
|
||||
omSetTra(object, 0.0f, 0.0f, 0.0f);
|
||||
omSetRot(object, 0.0f, 0.0f, 0.0f);
|
||||
omSetSca(object, 1.0f, 1.0f, 1.0f);
|
||||
return object;
|
||||
}
|
||||
|
||||
static void omInsertObj(Process *objman_process, omObjData *object)
|
||||
{
|
||||
omObjData *obj_new;
|
||||
omObjMan *objman = objman_process->user_data;
|
||||
omObjData *obj_all = objman->obj;
|
||||
s16 next_idx_alloc = object->next_idx_alloc;
|
||||
s16 prio = object->prio;
|
||||
s16 obj_idx;
|
||||
s16 prev_idx;
|
||||
if(objman->obj_first == -1) {
|
||||
object->prev = -1;
|
||||
object->next = -1;
|
||||
objman->obj_first = next_idx_alloc;
|
||||
objman->obj_last = next_idx_alloc;
|
||||
(void)objman; //HACK for matching
|
||||
return;
|
||||
}
|
||||
for(obj_idx = objman->obj_first; obj_idx != -1; obj_idx = obj_new->next) {
|
||||
obj_new = &obj_all[obj_idx];
|
||||
if(obj_new->prio <= prio) {
|
||||
break;
|
||||
}
|
||||
prev_idx = obj_idx;
|
||||
}
|
||||
if(obj_idx != -1) {
|
||||
object->prev = obj_new->prev;
|
||||
object->next = obj_idx;
|
||||
if(obj_new->prev != -1) {
|
||||
obj_all[obj_new->prev].next = next_idx_alloc;
|
||||
} else {
|
||||
objman->obj_first = next_idx_alloc;
|
||||
}
|
||||
obj_new->prev = next_idx_alloc;
|
||||
} else {
|
||||
object->next = -1;
|
||||
object->prev = prev_idx;
|
||||
obj_new->next = next_idx_alloc;
|
||||
objman->obj_last = next_idx_alloc;
|
||||
}
|
||||
}
|
||||
|
||||
void omAddMember(Process *objman_process, u16 group, omObjData *object)
|
||||
{
|
||||
omObjMan *objman = objman_process->user_data;
|
||||
omObjGroup *group_ptr = &objman->group[group];
|
||||
if(group_ptr->num_objs != group_ptr->max_objs) {
|
||||
object->group = group;
|
||||
object->group_idx = group_ptr->next_idx;
|
||||
group_ptr->obj[group_ptr->next_idx] = object;
|
||||
group_ptr->next_idx = group_ptr->next[group_ptr->next_idx];
|
||||
group_ptr->num_objs++;
|
||||
}
|
||||
}
|
||||
|
||||
void omDelObjEx(Process *objman_process, omObjData *object)
|
||||
{
|
||||
omObjMan *objman = objman_process->user_data;
|
||||
omObjData *obj_all = objman->obj;
|
||||
s16 next_idx_alloc = object->next_idx_alloc;
|
||||
if(objman->num_objs == 0 || object->stat == 1) {
|
||||
return;
|
||||
}
|
||||
objman->num_objs--;
|
||||
if(object->group >= 0) {
|
||||
omDelMember(objman_process, object);
|
||||
}
|
||||
if(object->motion != NULL) {
|
||||
HuMemDirectFree(object->motion);
|
||||
object->motion = NULL;
|
||||
}
|
||||
if(object->model != NULL) {
|
||||
HuMemDirectFree(object->model);
|
||||
object->model = NULL;
|
||||
}
|
||||
if(object->data != NULL) {
|
||||
HuMemDirectFree(object->data);
|
||||
object->data = NULL;
|
||||
}
|
||||
object->stat = 1;
|
||||
if(object->next >= 0) {
|
||||
obj_all[object->next].prev = object->prev;
|
||||
}
|
||||
if(object->prev >= 0) {
|
||||
obj_all[object->prev].next = object->next;
|
||||
}
|
||||
if(objman->num_objs != 0) {
|
||||
if(object->prev < 0) {
|
||||
objman->obj_first = obj_all[object->next].next_idx_alloc;
|
||||
}
|
||||
if(object->next < 0) {
|
||||
objman->obj_last = obj_all[object->prev].next_idx_alloc;
|
||||
}
|
||||
} else {
|
||||
objman->obj_first = objman->obj_last = -1;
|
||||
}
|
||||
object->next_idx = objman->next_idx;
|
||||
objman->next_idx = next_idx_alloc;
|
||||
}
|
||||
|
||||
void omDelMember(Process *objman_process, omObjData *object)
|
||||
{
|
||||
if(object->group != -1) {
|
||||
omObjMan *objman = objman_process->user_data;
|
||||
omObjData *obj_all = objman->obj;
|
||||
omObjGroup *group = &objman->group[object->group];
|
||||
group->obj[object->group_idx] = NULL;
|
||||
group->next[object->group_idx] = group->next_idx;
|
||||
group->next_idx = object->group_idx;
|
||||
object->group = -1;
|
||||
group->num_objs--;
|
||||
}
|
||||
}
|
||||
|
||||
void omMakeGroupEx(Process *objman_process, u16 group, u16 max_objs)
|
||||
{
|
||||
int i;
|
||||
omObjMan *objman = objman_process->user_data;
|
||||
omObjGroup *group_ptr = &objman->group[group];
|
||||
if(group_ptr->obj != NULL) {
|
||||
HuMemDirectFree(group_ptr->obj);
|
||||
}
|
||||
if(group_ptr->next != NULL) {
|
||||
HuMemDirectFree(group_ptr->next);
|
||||
}
|
||||
group_ptr->next_idx = 0;
|
||||
group_ptr->max_objs = max_objs;
|
||||
group_ptr->num_objs = 0;
|
||||
group_ptr->obj = HuMemDirectMallocNum(HEAP_SYSTEM, max_objs*sizeof(omObjData *), 0x10000000);
|
||||
group_ptr->next = HuMemDirectMallocNum(HEAP_SYSTEM, max_objs*sizeof(u16), 0x10000000);
|
||||
for(i=0; i<max_objs; i++) {
|
||||
group_ptr->obj[i] = NULL;
|
||||
group_ptr->next[i] = i+1;
|
||||
}
|
||||
}
|
||||
|
||||
omObjData **omGetGroupMemberListEx(Process *objman_process, s16 group)
|
||||
{
|
||||
omObjMan *objman = objman_process->user_data;
|
||||
return objman->group[group].obj;
|
||||
}
|
||||
|
||||
void omSetStatBit(omObjData *obj, u16 stat)
|
||||
{
|
||||
obj->stat |= stat;
|
||||
}
|
||||
|
||||
void omResetStatBit(omObjData *obj, u16 stat)
|
||||
{
|
||||
obj->stat &= ~stat;
|
||||
}
|
||||
|
||||
void omSetTra(omObjData *obj, float x, float y, float z)
|
||||
{
|
||||
obj->trans.x = x;
|
||||
obj->trans.y = y;
|
||||
obj->trans.z = z;
|
||||
}
|
||||
|
||||
void omSetRot(omObjData *obj, float x, float y, float z)
|
||||
{
|
||||
obj->rot.x = x;
|
||||
obj->rot.y = y;
|
||||
obj->rot.z = z;
|
||||
}
|
||||
|
||||
void omSetSca(omObjData *obj, float x, float y, float z)
|
||||
{
|
||||
obj->scale.x = x;
|
||||
obj->scale.y = y;
|
||||
obj->scale.z = z;
|
||||
}
|
||||
|
||||
void omMain(void)
|
||||
{
|
||||
Process *process = HuPrcCurrentGet();
|
||||
omObjMan *objman = process->user_data;
|
||||
omObjData *obj_all = objman->obj;
|
||||
omObjData *object;
|
||||
s16 obj_index;
|
||||
omDLLDBGOut();
|
||||
while(1) {
|
||||
if(omdispinfo) {
|
||||
float scale = 1.5f;
|
||||
GXColor color;
|
||||
color.a = 96;
|
||||
color.r = 0;
|
||||
color.g = 0;
|
||||
color.b = 255;
|
||||
printWin(7, 23, 128*scale, 40*scale, &color);
|
||||
fontcolor = 14;
|
||||
print8(8, 24, scale, "\xFD\x01H:%08lX(%ld)", HuMemUsedMallocSizeGet(HEAP_SYSTEM), HuMemUsedMallocBlockGet(HEAP_SYSTEM));
|
||||
print8(8, 24+(8*scale), scale, "\xFD\x01M:%08lX(%ld)", HuMemUsedMallocSizeGet(HEAP_DATA), HuMemUsedMallocBlockGet(HEAP_DATA));
|
||||
print8(8, 24+(16*scale), scale, "\xFD\x01OBJ:%d/%d", objman->num_objs, objman->max_objs);
|
||||
print8(8, 24+(24*scale), scale, "\xFD\x01OVL:%ld(%ld<%ld)", omovlhisidx, omcurovl, omprevovl);
|
||||
print8(8, 24+(32*scale), scale, "\xFD\x01POL:%ld", totalPolyCnted);
|
||||
}
|
||||
obj_index = objman->obj_last;
|
||||
while(obj_index != -1) {
|
||||
object = &obj_all[obj_index];
|
||||
obj_index = object->prev;
|
||||
if((object->stat & 0x3) == 0) {
|
||||
if(object->func != NULL && (object->stat & 0x58) == 0) {
|
||||
object->func(object);
|
||||
}
|
||||
if(omcurovl == -1 || objman->obj_last == -1) {
|
||||
break;
|
||||
}
|
||||
if((object->stat & 0x3) == 0) {
|
||||
if((obj_all[obj_index].stat & 0x3) != 0) {
|
||||
obj_index = object->prev;
|
||||
}
|
||||
if(object->model != NULL && object->model[0] != -1 && !(object->stat & 0x100)) {
|
||||
Hu3DModelPosSet(object->model[0], object->trans.x, object->trans.y, object->trans.z);
|
||||
Hu3DModelRotSet(object->model[0], object->rot.x, object->rot.y, object->rot.z);
|
||||
Hu3DModelScaleSet(object->model[0], object->scale.x, object->scale.y, object->scale.z);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
HuPrcVSleep();
|
||||
}
|
||||
}
|
||||
|
||||
//Dummy function to force string literals in binary
|
||||
static void omDumpObj(Process *objman_process)
|
||||
{
|
||||
omObjMan *objman = objman_process->user_data;
|
||||
omObjData *obj_all = objman->obj;
|
||||
int i;
|
||||
OSReport("=================== 現在登録されている OBJECT ==================\n");
|
||||
OSReport("STAT PRI GRPN MEMN PROG (TRA) (ROT) (SCA) mdlcnt mtncnt work[0] work[1] work[2] work[3] *data\n");
|
||||
for(i=0; i<objman->max_objs; i++) {
|
||||
omObjData *object = &obj_all[i];
|
||||
OSReport("%04d:%04X %04X %d %d %08X (%.2f %.2f %.2f) (%.2f %.2f %.2f) (%.2f %.2f %.2f) %d %d %08X %08X %08X %08X %08X\n",
|
||||
object->stat, object->stat, object->prio, object->group, object->unk10, object->func,
|
||||
object->trans.x, object->trans.y, object->trans.z,
|
||||
object->rot.x, object->rot.y, object->rot.z,
|
||||
object->scale.x, object->scale.y, object->scale.z,
|
||||
object->mdlcnt, object->mtncnt, object->work[0], object->work[1], object->work[2], object->work[3], object->data);
|
||||
}
|
||||
OSReport("================================================================\n");
|
||||
}
|
||||
|
||||
void omAllPause(BOOL pause)
|
||||
{
|
||||
Process *objman_process = HuPrcCurrentGet();
|
||||
omObjMan *objman = objman_process->user_data;
|
||||
int i;
|
||||
if(pause) {
|
||||
for(i=0; i<objman->max_objs; i++) {
|
||||
if((objman->obj[i].stat & 0x21) == 0) {
|
||||
omSetStatBit(&objman->obj[i], 0x10);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for(i=0; i<objman->max_objs; i++) {
|
||||
if((objman->obj[i].stat & 0x21) == 0) {
|
||||
omResetStatBit(&objman->obj[i], 0x10);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
char omPauseChk(void)
|
||||
{
|
||||
if(omDBGSysKeyObj == NULL) {
|
||||
return 0;
|
||||
} else {
|
||||
return omDBGSysKeyObj->work[0] & 0x1;
|
||||
}
|
||||
}
|
||||
|
||||
OverlayID omCurrentOvlGet(void)
|
||||
{
|
||||
return omcurovl;
|
||||
}
|
||||
11
src/game/ovllist.c
Normal file
11
src/game/ovllist.c
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
#include "common.h"
|
||||
|
||||
|
||||
#define OVL_DEFINE(name, path) { path, 0 },
|
||||
|
||||
FileListEntry _ovltbl[OVL_COUNT+1] = {
|
||||
#include "ovl_table.h"
|
||||
{ NULL, -1 }
|
||||
};
|
||||
|
||||
#undef OVL_DEFINE
|
||||
|
|
@ -1,28 +1,53 @@
|
|||
#include "common.h"
|
||||
#include "dolphin/mtx.h"
|
||||
#include "dolphin/gx.h"
|
||||
#include "dolphin/vi.h"
|
||||
#include "stdio.h"
|
||||
#include "stdarg.h"
|
||||
|
||||
extern u8 ank8x8_4b[];
|
||||
|
||||
struct strline_data {
|
||||
u16 type;
|
||||
u16 last_idx;
|
||||
u16 color;
|
||||
s16 x;
|
||||
s16 y;
|
||||
s16 w;
|
||||
s16 h;
|
||||
s16 empty_line;
|
||||
s16 empstrline_next;
|
||||
float scale;
|
||||
char str[80];
|
||||
GXColor color;
|
||||
GXColor win_color;
|
||||
};
|
||||
|
||||
static struct strline_data strline[256];
|
||||
static char pfStrBuf[256];
|
||||
|
||||
BOOL saftyFrameF;
|
||||
u16 strlinecnt;
|
||||
u16 empstrline;
|
||||
int fontcolor;
|
||||
u16 empstrline;
|
||||
u16 strlinecnt;
|
||||
BOOL saftyFrameF;
|
||||
|
||||
void pfClsScr(void);
|
||||
static void WireDraw(void);
|
||||
|
||||
static GXColor ATTRIBUTE_ALIGN(32) fcoltbl[16] = {
|
||||
{ 0, 0, 0, 255 },
|
||||
{ 0, 0, 128, 255 },
|
||||
{ 128, 0, 0, 255 },
|
||||
{ 128, 0, 128, 255 },
|
||||
{ 0, 128, 0, 255 },
|
||||
{ 0, 128, 128, 255 },
|
||||
{ 128, 128, 0, 255 },
|
||||
{ 128, 128, 128, 255 },
|
||||
{ 128, 128, 128, 128 },
|
||||
{ 0, 0, 255, 255 },
|
||||
{ 255, 0, 0, 255 },
|
||||
{ 255, 0, 255, 255 },
|
||||
{ 0, 255, 0, 255 },
|
||||
{ 0, 255, 255, 255 },
|
||||
{ 255, 255, 0, 255 },
|
||||
{ 255, 255, 255, 255 }
|
||||
};
|
||||
|
||||
void pfInit(void)
|
||||
{
|
||||
|
|
@ -42,10 +67,286 @@ void pfClsScr(void)
|
|||
empstrline = 0;
|
||||
strlinecnt = 0;
|
||||
for (i = 0; i < 256; i++) {
|
||||
strline[i].empty_line = i+1;
|
||||
strline[i].empstrline_next = i+1;
|
||||
strline[i].type = 0;
|
||||
if (strline[i].str[0] != 0) {
|
||||
strline[i].str[0] = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
s16 print8(s16 x, s16 y, float scale, char *str, ...)
|
||||
{
|
||||
struct strline_data *strline_curr;
|
||||
char *src = pfStrBuf;
|
||||
char *dst;
|
||||
s16 ret;
|
||||
va_list list;
|
||||
strline_curr = &strline[empstrline];
|
||||
if(strlinecnt >= 256) {
|
||||
return -1;
|
||||
}
|
||||
va_start(list, str);
|
||||
vsprintf(pfStrBuf, str, list);
|
||||
strlinecnt++;
|
||||
ret = empstrline;
|
||||
empstrline = strline_curr->empstrline_next;
|
||||
strline_curr->type = 0;
|
||||
strline_curr->color = fontcolor;
|
||||
strline_curr->x = x;
|
||||
strline_curr->y = y;
|
||||
strline_curr->scale = scale;
|
||||
dst = strline_curr->str;
|
||||
while(*src) {
|
||||
*dst++ = *src++;
|
||||
}
|
||||
*dst = 0;
|
||||
va_end(list);
|
||||
return ret;
|
||||
}
|
||||
|
||||
s16 printWin(s16 x, s16 y, s16 w, s16 h, GXColor *color)
|
||||
{
|
||||
struct strline_data *strline_curr;
|
||||
s16 ret;
|
||||
char *src = pfStrBuf;
|
||||
strline_curr = &strline[empstrline];
|
||||
if(strlinecnt >= 256) {
|
||||
return -1;
|
||||
}
|
||||
strlinecnt++;
|
||||
ret = empstrline;
|
||||
empstrline = strline_curr->empstrline_next;
|
||||
strline_curr->type = 1;
|
||||
strline_curr->win_color.r = color->r;
|
||||
strline_curr->win_color.g = color->g;
|
||||
strline_curr->win_color.b = color->b;
|
||||
strline_curr->win_color.a = color->a;
|
||||
strline_curr->x = x;
|
||||
strline_curr->y = y;
|
||||
strline_curr->w = w;
|
||||
strline_curr->h = h;
|
||||
return ret;
|
||||
}
|
||||
|
||||
void pfDrawFonts(void)
|
||||
{
|
||||
GXTexObj font_tex;
|
||||
Mtx44 proj;
|
||||
Mtx modelview;
|
||||
int i;
|
||||
s16 x, y, w, h;
|
||||
|
||||
u16 strline_count = strlinecnt;
|
||||
if(saftyFrameF) {
|
||||
WireDraw();
|
||||
}
|
||||
MTXOrtho(proj, 0, 480, 0, 640, 0, 10);
|
||||
GXSetProjection(proj, GX_ORTHOGRAPHIC);
|
||||
MTXIdentity(modelview);
|
||||
GXLoadPosMtxImm(modelview, GX_PNMTX0);
|
||||
GXSetCurrentMtx(GX_PNMTX0);
|
||||
GXSetViewport(0, 0, RenderMode->fbWidth, RenderMode->efbHeight, 0, 1);
|
||||
GXSetScissor(0, 0, RenderMode->fbWidth, RenderMode->efbHeight);
|
||||
GXClearVtxDesc();
|
||||
GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
|
||||
GXSetVtxDesc(GX_VA_CLR0, GX_INDEX8);
|
||||
GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT);
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_S16, 0);
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGBA, GX_RGBA8, 0);
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0);
|
||||
GXSetArray(GX_VA_CLR0, fcoltbl, sizeof(GXColor));
|
||||
GXSetZMode(GX_FALSE, GX_ALWAYS, GX_FALSE);
|
||||
GXInvalidateTexAll();
|
||||
GXInitTexObj(&font_tex, ank8x8_4b, 128, 128, GX_TF_I4, GX_CLAMP, GX_CLAMP, GX_FALSE);
|
||||
GXInitTexObjLOD(&font_tex, GX_NEAR, GX_NEAR, 0, 0, 0, GX_FALSE, GX_FALSE, GX_ANISO_1);
|
||||
GXLoadTexObj(&font_tex, GX_TEXMAP0);
|
||||
GXSetNumTevStages(1);
|
||||
GXSetNumTexGens(1);
|
||||
GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR0A0);
|
||||
GXSetTexCoordGen(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY);
|
||||
GXSetTevOp(GX_TEVSTAGE0, GX_MODULATE);
|
||||
GXSetNumChans(1);
|
||||
GXSetChanCtrl(GX_COLOR0A0, GX_FALSE, GX_SRC_VTX, GX_SRC_VTX, GX_LIGHT0, GX_DF_CLAMP, GX_AF_SPOT);
|
||||
GXSetZCompLoc(GX_FALSE);
|
||||
GXSetAlphaCompare(GX_GEQUAL, 1, GX_AOP_AND, GX_GEQUAL, 1);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_NOOP);
|
||||
GXSetAlphaUpdate(GX_TRUE);
|
||||
for(i=0; i<256; i++) {
|
||||
x = strline[i].x;
|
||||
y = strline[i].y;
|
||||
if(strline[i].type == 1) {
|
||||
w = strline[i].w;
|
||||
h = strline[i].h;
|
||||
GXClearVtxDesc();
|
||||
GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XY, GX_S16, 0);
|
||||
GXSetTevColor(GX_TEVREG0, strline[i].win_color);
|
||||
GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
|
||||
GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_C0, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO);
|
||||
GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_A0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetNumTevStages(1);
|
||||
GXSetNumTexGens(0);
|
||||
GXBegin(GX_QUADS, GX_VTXFMT0, 4);
|
||||
GXPosition2s16(x, y);
|
||||
GXPosition2s16(x+w, y);
|
||||
GXPosition2s16(x+w, y+h);
|
||||
GXPosition2s16(x, y+h);
|
||||
GXEnd();
|
||||
GXClearVtxDesc();
|
||||
GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
|
||||
GXSetVtxDesc(GX_VA_CLR0, GX_INDEX8);
|
||||
GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT);
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_S16, 0);
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGBA, GX_RGBA8, 0);
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0);
|
||||
GXSetArray(GX_VA_CLR0, fcoltbl, sizeof(GXColor));
|
||||
GXSetNumTevStages(1);
|
||||
GXSetNumTexGens(1);
|
||||
GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR0A0);
|
||||
GXSetTexCoordGen(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY);
|
||||
GXSetTevOp(GX_TEVSTAGE0, GX_MODULATE);
|
||||
} else {
|
||||
if(strline[i].str[0] != '\0') {
|
||||
float shadow_ofs_x, shadow_ofs_y;
|
||||
float char_w;
|
||||
float char_h;
|
||||
float texcoord_x, texcoord_y;
|
||||
char *str;
|
||||
u16 color;
|
||||
s16 shadow_color;
|
||||
float scale;
|
||||
char_w = char_h = 8.0f*strline[i].scale;
|
||||
str = strline[i].str;
|
||||
color = strline[i].color;
|
||||
shadow_color = -1;
|
||||
scale = 1.0f;
|
||||
while(*str) {
|
||||
char c = *str++;
|
||||
switch(c) {
|
||||
case 255:
|
||||
c = *str++;
|
||||
scale = c/16.0f;
|
||||
char_w = 8.0f*strline[i].scale*scale;
|
||||
char_h = 8.0f*strline[i].scale*scale;
|
||||
break;
|
||||
|
||||
case 254:
|
||||
color = (*str++)-1;
|
||||
break;
|
||||
|
||||
case 253:
|
||||
shadow_color = (*str++)-1;
|
||||
shadow_ofs_x = 1.3333333f*strline[i].scale*scale;
|
||||
shadow_ofs_y = 1.3333333f*strline[i].scale*scale;
|
||||
break;
|
||||
|
||||
default:
|
||||
texcoord_x = (c%16)/16.0f;
|
||||
texcoord_y = ((c/16)/16.0f)+(1/128.0f);
|
||||
if(shadow_color < 0) {
|
||||
GXBegin(GX_QUADS, GX_VTXFMT0, 4);
|
||||
GXPosition3s16(x, y, 0);
|
||||
GXColor1x8(color);
|
||||
GXTexCoord2f32(texcoord_x, texcoord_y);
|
||||
GXPosition3s16(x+char_w, y, 0);
|
||||
GXColor1x8(color);
|
||||
GXTexCoord2f32(texcoord_x+(1/16.0f), texcoord_y);
|
||||
GXPosition3s16(x+char_w, y+char_h, 0);
|
||||
GXColor1x8(color);
|
||||
GXTexCoord2f32(texcoord_x+(1/16.0f), texcoord_y+(1/16.0f));
|
||||
GXPosition3s16(x, y+char_h, 0);
|
||||
GXColor1x8(color);
|
||||
GXTexCoord2f32(texcoord_x, texcoord_y+(1/16.0f));
|
||||
GXEnd();
|
||||
} else {
|
||||
GXBegin(GX_QUADS, GX_VTXFMT0, 8);
|
||||
GXPosition3s16(x+shadow_ofs_x, y+shadow_ofs_y, 0);
|
||||
GXColor1x8(shadow_color);
|
||||
GXTexCoord2f32(texcoord_x, texcoord_y);
|
||||
GXPosition3s16(x+char_w+shadow_ofs_x, y+shadow_ofs_y, 0);
|
||||
GXColor1x8(shadow_color);
|
||||
GXTexCoord2f32(texcoord_x+(1/16.0f), texcoord_y);
|
||||
GXPosition3s16(x+char_w+shadow_ofs_x, y+char_h+shadow_ofs_y, 0);
|
||||
GXColor1x8(shadow_color);
|
||||
GXTexCoord2f32(texcoord_x+(1/16.0f), texcoord_y+(1/16.0f));
|
||||
GXPosition3s16(x+shadow_ofs_x, y+char_h+shadow_ofs_y, 0);
|
||||
GXColor1x8(shadow_color);
|
||||
GXTexCoord2f32(texcoord_x, texcoord_y+(1/16.0f));
|
||||
GXPosition3s16(x, y, 0);
|
||||
GXColor1x8(color);
|
||||
GXTexCoord2f32(texcoord_x, texcoord_y);
|
||||
GXPosition3s16(x+char_w, y, 0);
|
||||
GXColor1x8(color);
|
||||
GXTexCoord2f32(texcoord_x+(1/16.0f), texcoord_y);
|
||||
GXPosition3s16(x+char_w, y+char_h, 0);
|
||||
GXColor1x8(color);
|
||||
GXTexCoord2f32(texcoord_x+(1/16.0f), texcoord_y+(1/16.0f));
|
||||
GXPosition3s16(x, y+char_h, 0);
|
||||
GXColor1x8(color);
|
||||
GXTexCoord2f32(texcoord_x, texcoord_y+(1/16.0f));
|
||||
GXEnd();
|
||||
}
|
||||
x += char_w;
|
||||
if(x > 640) {
|
||||
x = 0;
|
||||
y += char_h;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void WireDraw(void)
|
||||
{
|
||||
Mtx44 proj;
|
||||
Mtx modelview;
|
||||
MTXOrtho(proj, 0, 480, 0, 576, 0, 10);
|
||||
GXSetProjection(proj, GX_ORTHOGRAPHIC);
|
||||
if(RenderMode->field_rendering) {
|
||||
GXSetViewportJitter(0, 0, 640, 480, 0, 1, VIGetNextField());
|
||||
} else {
|
||||
GXSetViewport(0, 0, 640, 480, 0, 1);
|
||||
}
|
||||
GXSetScissor(0, 0, 640, 480);
|
||||
GXClearVtxDesc();
|
||||
GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XY, GX_F32, 0);
|
||||
GXSetVtxDesc(GX_VA_CLR0, GX_DIRECT);
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGB, GX_RGB8, 0);
|
||||
GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
|
||||
GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_RASC, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO);
|
||||
GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_KONST, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetNumTexGens(0);
|
||||
GXSetNumTevStages(1);
|
||||
GXSetZMode(GX_FALSE, GX_ALWAYS, GX_FALSE);
|
||||
GXSetNumChans(1);
|
||||
GXSetChanCtrl(GX_COLOR0A0, GX_FALSE, GX_SRC_REG, GX_SRC_VTX, GX_LIGHT_NULL, GX_DF_CLAMP, GX_AF_NONE);
|
||||
MTXIdentity(modelview);
|
||||
GXLoadPosMtxImm(modelview, GX_PNMTX0);
|
||||
GXBegin(GX_LINES, 0, 8);
|
||||
GXPosition2f32(16, 40);
|
||||
GXColor3u8(255, 0, 0);
|
||||
GXPosition2f32(16, 440);
|
||||
GXColor3u8(255, 0, 0);
|
||||
GXPosition2f32(16, 40);
|
||||
GXColor3u8(255, 0, 0);
|
||||
GXPosition2f32(560, 40);
|
||||
GXColor3u8(255, 0, 0);
|
||||
GXPosition2f32(560, 440);
|
||||
GXColor3u8(255, 0, 0);
|
||||
GXPosition2f32(560, 40);
|
||||
GXColor3u8(255, 0, 0);
|
||||
GXPosition2f32(560, 440);
|
||||
GXColor3u8(255, 0, 0);
|
||||
GXPosition2f32(16, 440);
|
||||
GXColor3u8(255, 0, 0);
|
||||
GXEnd();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -70,7 +70,7 @@ Process *HuPrcCreate(void (*func)(void), u16 prio, u32 stack_size, s32 extra_siz
|
|||
alloc_size = HuMemMemoryAllocSizeGet(sizeof(Process))
|
||||
+HuMemMemoryAllocSizeGet(stack_size)
|
||||
+HuMemMemoryAllocSizeGet(extra_size);
|
||||
if(!(heap = HuMemDirectMalloc(0, alloc_size))) {
|
||||
if(!(heap = HuMemDirectMalloc(HEAP_SYSTEM, alloc_size))) {
|
||||
OSReport("process> malloc error size %d\n", alloc_size);
|
||||
return NULL;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue