diff --git a/src/2D340.c b/src/2D340.c index c34e310..5f91eef 100644 --- a/src/2D340.c +++ b/src/2D340.c @@ -226,9 +226,167 @@ s32* func_8002CD58(s32* arg0, s32* arg1, s32* arg2, s32 (*arg3)(s32, s32)) { : arg0; } -#pragma GLOBAL_ASM("asm/us/nonmatchings/2D340/func_8002CE34.s") +#ifdef NON_MATCHING +void func_8002CE34(void** base, s32 n, s32 (*cmp)(s32, s32)) { + void** sp8C; + s32 temp_s1; + s32 temp_s2; + s32 temp_s3; + void* temp_s4; + s32 temp_s4_2; + void* temp_t7_2; + void* temp_t8; + void* temp_v0; + s32 temp_v0_2; + void* temp_v0_3; + void* temp_v0_4; + void* temp_v0_5; + s32 temp_v0_6; + s32 temp_v0_7; + s32 var_a2_2; + s32 var_a2_3; + s32 var_v0; + s32 var_v0_2; + void** var_a2; + void** temp_t5; + void** temp_t7; + void** var_s0; + void** var_s0_2; + void** var_s1; + void** var_s1_2; + void** var_s2; + void** var_s2_2; + void** var_s3; + s32 pad[1]; + void** sp44; -void func_8002CE34(u8*, s32, s32 (*arg1)(s32, s32)); + while(1) { + var_s2 = base; + if (n < 7) { + temp_t7 = n + base; + sp44 = temp_t7; + var_s1 = base; + if (base < temp_t7) { + do { + var_s0 = var_s1; + if ((base < var_s1) && (cmp(*(var_s1 - 1), *var_s1) > 0)) { + while(1) { + temp_v0 = *var_s0; + temp_t8 = *(var_s0 - 1); + var_s0 -= 1; + *var_s0 = temp_v0; + *(var_s0 + 1) = temp_t8; + if (base < var_s0) { + if (cmp(*(var_s0 - 1), *var_s0) > 0) { + continue; + } + } + break; + } + } + var_s1 += 1; + } while (var_s1 < sp44); + } + } else { + sp8C = ((n / 2) * 1) + base; + if (n >= 8) { + var_a2 = ((n * 4) + base) - 4; + if (n >= 0x29) { + temp_v0_2 = n / 8; + temp_s1 = temp_v0_2 * 4; + temp_s3 = temp_v0_2 * 8; + var_s2 = func_8002CD58(base, temp_s1 + base, temp_s3 + base, cmp); + sp8C = func_8002CD58(sp8C - temp_s1, sp8C, &sp8C[temp_v0_2], cmp); + var_a2 = func_8002CD58(var_a2 - temp_s3, var_a2 - temp_s1, var_a2, cmp); + } + sp8C = func_8002CD58(var_s2, sp8C, var_a2, cmp); + } + temp_t5 = (n * 4) + base; + var_s3 = temp_t5 - 4; + temp_s4 = *sp8C; + sp44 = temp_t5; + var_s0_2 = var_s3; + var_s2_2 = base; + var_s1_2 = base; + loop_14: + if (var_s0_2 >= var_s1_2) { + var_v0 = cmp(*var_s1_2, temp_s4); + if (var_v0 <= 0) { + loop_16: + if (var_v0 == 0) { + temp_v0_3 = *var_s2_2; + var_s2_2 += 1; + *(var_s2_2 - 1) = *var_s1_2; + *var_s1_2 = temp_v0_3; + } + var_s1_2 += 1; + if (var_s0_2 >= var_s1_2) { + var_v0 = cmp(*var_s1_2, temp_s4); + if (var_v0 <= 0) { + goto loop_16; + } + } + } + } + if (var_s0_2 >= var_s1_2) { + var_v0_2 = cmp(*var_s0_2, temp_s4); + if (var_v0_2 >= 0) { + loop_22: + if (var_v0_2 == 0) { + temp_t7_2 = *var_s3; + temp_v0_4 = *var_s0_2; + var_s3 -= 1; + *var_s0_2 = temp_t7_2; + *(var_s3 + 1) = temp_v0_4; + } + var_s0_2 -= 1; + if (var_s0_2 >= var_s1_2) { + var_v0_2 = cmp(*var_s0_2, temp_s4); + if (var_v0_2 >= 0) { + goto loop_22; + } + } + } + } + if (var_s0_2 >= var_s1_2) { + temp_v0_5 = *var_s1_2; + var_s1_2 += 1; + *(var_s1_2 - 1) = *var_s0_2; + var_s0_2 -= 1; + *(var_s0_2 + 1) = temp_v0_5; + goto loop_14; + } + temp_s4_2 = (s32) (var_s1_2 - var_s2_2); + temp_v0_6 = (s32) (var_s2_2 - base); + if (temp_v0_6 < temp_s4_2) { + var_a2_2 = temp_v0_6; + } else { + var_a2_2 = temp_s4_2; + } + func_8002CCC4(base, var_s1_2 - var_a2_2, var_a2_2); + temp_s2 = (s32) (var_s3 - var_s0_2); + temp_v0_7 = ((s32) (sp44 - var_s3)) - 1; + if (temp_s2 < temp_v0_7) { + var_a2_3 = temp_s2; + } else { + var_a2_3 = temp_v0_7; + } + func_8002CCC4(var_s1_2, sp44 - var_a2_3, var_a2_3); + if (temp_s4_2 >= 2) { + func_8002CE34(base, temp_s4_2, cmp); + } + if (temp_s2 >= 2) { + base = sp44 - temp_s2; + n = temp_s2; + continue; + } + } + return; + } +} +#else +#pragma GLOBAL_ASM("asm/us/nonmatchings/2D340/func_8002CE34.s") +#endif void func_8002D180(unk_func_8830867C_02C_0CC* arg0, s32 (*arg1)(s32, s32)) { func_8002CE34(arg0->unk_00, arg0->unk_08, arg1); diff --git a/src/30640.c b/src/30640.c index 7f0523d..237518f 100644 --- a/src/30640.c +++ b/src/30640.c @@ -1,6 +1,7 @@ #include "30640.h" #include "include/math.h" #include "src/fragments/15/fragment15.h" +#include "src/fragments/31/fragment31.h" #include "src/fragments/34/fragment34.h" #include "src/11BA0.h" #include "src/12D80.h" @@ -37,6 +38,11 @@ typedef struct unk_func_8003013C_arg1 { /* 0x1E */ s16 unk_1E; } unk_func_8003013C_arg1; // size >= 0x20 +typedef struct unk_func_80031660_sp24 { + /* 0x00 */ u8 pad00[0x18]; + /* 0x18 */ s32 unk_18; +} unk_func_80031660_sp24; // size = 0x1C + extern unk_func_80031270* D_80075F80; extern unk_func_80031270* D_80075F84; extern u32* D_80075F88; @@ -410,7 +416,7 @@ void func_800302A4(s32 arg0, s32 arg1) { #ifdef NON_MATCHING s32 func_800303C8(s32 arg0, UNUSED GraphNode* arg1) { - char* sp16C; + char* sp16C; u8* sp40; char* temp_s2; s32 temp_v0; @@ -665,8 +671,85 @@ unk_func_80031270* func_80031270(s16 arg0, s16 arg1, unk_D_80068BB0* arg2, unk_D return temp_v0; } -void func_80031390(unk_func_80031270*); -#pragma GLOBAL_ASM("asm/us/nonmatchings/30640/func_80031390.s") +typedef union unk_func_80026268_arg0_000_raw { + struct { + u8 unk_00; + u8 unk_01; + u16 unk_02; + }; + f32 raw; +} unk_func_80026268_arg0_000_raw; // size = 0x4 + +typedef struct unk_func_80026268_arg0_raw { + /* 0x00 */ unk_func_80026268_arg0_000_raw unk_00; + /* 0x04 */ u8 unk_04; + /* 0x05 */ u8 unk_05; + /* 0x06 */ s16 unk_06; + /* 0x08 */ u8 unk_08; + /* 0x09 */ u8 unk_09[4]; + /* 0x0D */ u8 pad0D; + /* 0x0E */ u16 unk_0E; + /* 0x10 */ u32 unk_10; + /* 0x14 */ u16 unk_14; + /* 0x16 */ u16 unk_16; + /* 0x18 */ u16 unk_18; + /* 0x1A */ u16 unk_1A; + /* 0x1C */ u16 unk_1C; + /* 0x1E */ u16 unk_1E; + /* 0x20 */ u8 unk_20[4]; + /* 0x24 */ u8 unk_24; + /* 0x25 */ u8 unk_25; + /* 0x26 */ u16 unk_26; + /* 0x28 */ u16 unk_28; + /* 0x2A */ u16 unk_2A; + /* 0x2C */ u16 unk_2C; + /* 0x2E */ u16 unk_2E; + /* 0x30 */ u8 unk_30[11]; + /* 0x3B */ u8 unk_3B[11]; + /* 0x46 */ u8 unk_46[11]; + /* 0x51 */ char unk51[0x1]; + /* 0x52 */ u8 unk_52; + /* 0x53 */ u8 unk_53; +} unk_func_80026268_arg0_raw; // size = 0x54 + +typedef struct unk_D_83403C60_raw { + /* 0x00 */ unk_func_80026268_arg0_raw unk_00; + /* 0x54 */ char unk54[0x18]; + /* 0x6C */ u8 unk_6C; + /* 0x6D */ char unk6D[0x3]; + /* 0x70 */ unk_D_83407AC8 unk_70; + /* 0x8A */ char unk8A[0x2]; +} unk_D_83403C60_raw; // size = 0x8C + +void func_80031390(unk_func_80031270* arg0) { + s32 sp94; + arg1_func_80010CA8 sp90; + UNUSED s32 pad[3]; // unk_func_80026268_arg0 potentially bigger? + unk_func_80026268_arg0 sp30; + unk_D_83403C60_raw* temp_s1; + void (*sp28)(void*, u32); + + temp_s1 = (unk_D_83403C60_raw*)arg0->unk_18; + func_80031140(&sp30, &temp_s1->unk_70); + func_8000E88C(&arg0->unk_20->unk_024, 0, temp_s1->unk_00.unk_00.raw, 0); //? + arg0->unk_20->unk_0A6 = 0xFE; + sp94 = sp30.unk_00.unk_00; + if (sp30.unk_00.unk_00 == 0x99) { + sp30.unk_00.unk_00 = 0x19; + } + func_8001BEE8(&sp90, &sp30); + sp30.unk_00.unk_00 = sp94; + func_800198E4(arg0->unk_10, sp30.unk_00.unk_00, sp90); + func_80019CA8(arg0->unk_10); + func_8001BCF0(arg0->unk_20); + func_8001BC34(arg0->unk_20, 0, sp30.unk_00.unk_00, arg0->unk_10->unk_24->unk_08->unk_00[0]); + sp28 = Util_ConvertAddrToVirtAddr(&func_81002260); + sp28(arg0->unk_20, Util_ConvertAddrToVirtAddr(&temp_s1->unk_00.unk_09[1])); + func_8001BD04(arg0->unk_20, temp_s1->unk_00.unk_05); + func_80017464(arg0->unk_20, temp_s1->unk_00.unk_06); + func_8001BD9C(arg0->unk_20, temp_s1->unk_00.unk_08); + func_80017804(arg0->unk_20, (s16)temp_s1->unk_00.unk_09[0]); +} void func_800314BC(unk_func_80031270* arg0) { MemoryBlock* sp24; @@ -711,58 +794,56 @@ void func_800314BC(unk_func_80031270* arg0) { temp_v1->unk_01 = (u8) (temp_v1->unk_01 | 1); } -#ifdef NON_MATCHING u8* func_80031660(unk_func_80031270* arg0) { - void* sp24; + unk_func_80031660_sp24* sp24; void (*sp20)(); - u32 temp_v0_2; - void* v0_ptr; - sp24 = (arg0->unk_18 + 0x50); + sp24 = (unk_func_80031660_sp24*)((u8*)arg0->unk_18 + 0x50); sp20 = Util_ConvertAddrToVirtAddr(&func_8140C734); D_80075F84 = arg0; if (arg0->unk_00 == 1) { - if (arg0->unk_02 != 1) { - if (arg0->unk_02 == 2) { + switch (arg0->unk_02) { + case 2: func_80031390(arg0); func_800314BC(arg0); - } - } else { - func_80006498(&gDisplayListHead, arg0->unk_08); - temp_v0_2 = arg0->unk_34; - if ((temp_v0_2 == -1U) || (temp_v0_2 == 0)) { - func_8000699C(&gDisplayListHead, 1); - } else if (temp_v0_2 < 0x10000U) { - func_8000699C(&gDisplayListHead, temp_v0_2 & 0xFFFF); - } else { - func_8000699C(&gDisplayListHead, 0xA6BF); - } - func_80015348(); - v0_ptr = Util_ConvertAddrToVirtAddr(&D_8140E6B8); - v0_ptr = (s32) sp24; - sp20(); - func_80015094(arg0->unk_1C); + break; + case 1: + func_80006498(&gDisplayListHead, arg0->unk_08); + + if ((arg0->unk_34 == -1) || (arg0->unk_34 == 0)) { + func_8000699C(&gDisplayListHead, 1); + } else if (arg0->unk_34 < 0x10000U) { + func_8000699C(&gDisplayListHead, arg0->unk_34); + } else { + func_8000699C(&gDisplayListHead, 0xA6BF); + } + func_80015348(); + *((s32*)Util_ConvertAddrToVirtAddr(&D_8140E6B8)) = sp24->unk_18; + sp20(); + func_80015094(arg0->unk_1C); + break; + default: + break; } + } - switch (arg0->unk_00) { /* irregular */ - case 0: - arg0->unk_00 = 1U; - arg0->unk_02 = 2; - break; - case 1: - arg0->unk_02--; - if (arg0->unk_02 <= 0) { - arg0->unk_00 = 2U; - } - break; - case 2: - break; + switch (arg0->unk_00) { + case 0: + arg0->unk_00 = 1; + arg0->unk_02 = 2; + break; + case 1: + arg0->unk_02--; + if (arg0->unk_02 <= 0) { + arg0->unk_00 = 2; + } + break; + case 2: + break; } return arg0->unk_08->img_p; } -#else -#pragma GLOBAL_ASM("asm/us/nonmatchings/30640/func_80031660.s") -#endif + s32 func_800317D8(unk_func_80031270* arg0) { s32 var_v1; s32 sp1C; diff --git a/src/38BB0.c b/src/38BB0.c index dcf2bbb..9d1d48e 100644 --- a/src/38BB0.c +++ b/src/38BB0.c @@ -488,9 +488,8 @@ void func_80038B54(u8* arg0, u32 arg1) { *arg0++ = arg1 & 0xFF; } -#ifdef NON_MATCHING s32 func_80038B68(sp38_func_800373D8* arg0) { - UNUSED s32 pad[2]; + UNUSED s32 pad[1]; s32 i; ALSynConfig sp4C; amConfig sp40; @@ -507,18 +506,16 @@ s32 func_80038B68(sp38_func_800373D8* arg0) { func_8003C1D0(arg0->unk_0C, 0, arg0->unk_10); alHeapInit(&D_800FC7B8, arg0->unk_0C, arg0->unk_10); D_800FC810 = &D_800FC7B8; - D_800FC7D0 = alHeapAlloc(&D_800FC7B8, 1, D_800FC7CC * sizeof(unk_D_800FC7D0)); - func_8003C1D0(D_800FC7D0, 0, D_800FC7CC * sizeof(unk_D_800FC7D0)); + D_800FC7D0 = alHeapDBAlloc(NULL, 0, &D_800FC7B8, 1, D_800FC7CC * sizeof(unk_D_800FC7D0)); + func_8003C1D0((u8*)D_800FC7D0, 0, D_800FC7CC * sizeof(unk_D_800FC7D0)); - D_800FC7E8 = alHeapAlloc(&D_800FC7B8, 1, arg0->unk_2C); + D_800FC7E8 = alHeapDBAlloc(NULL, 0, &D_800FC7B8, 1, arg0->unk_2C); D_800FC7EC = 0; D_800FC7F0 = arg0->unk_2C; - D_800FC7FC = alHeapAlloc(&D_800FC7B8, arg0->unk_04, sizeof(unk_D_800FC7D0_148)); - D_800FC804 = NULL; - D_800FC800 = NULL; - D_800FC808 = NULL; - D_800FC80C = NULL; + D_800FC7FC = alHeapDBAlloc(NULL, 0, &D_800FC7B8, arg0->unk_04, sizeof(unk_D_800FC7D0_148)); + D_800FC800 = D_800FC804 = NULL; + D_800FC808 = D_800FC80C = NULL; D_800FC818 = 0; D_800FC81C = 0; @@ -563,9 +560,6 @@ s32 func_80038B68(sp38_func_800373D8* arg0) { return D_800FC7B8.cur - D_800FC7B8.base; } -#else -#pragma GLOBAL_ASM("asm/us/nonmatchings/38BB0/func_80038B68.s") -#endif void func_80038E98(s32 arg0, u32 arg1) { u8* temp_a0; diff --git a/src/38BB0.h b/src/38BB0.h index 974e7d1..a105ec8 100644 --- a/src/38BB0.h +++ b/src/38BB0.h @@ -53,7 +53,7 @@ typedef struct unk_D_800FC7D0_148 { /* 0x24 */ s32 unk_24; /* 0x28 */ u16 unk_28; /* 0x2A */ u8 unk_2A; -} unk_D_800FC7D0_148; // size >= 0x2C +} unk_D_800FC7D0_148; // size = 0x2C typedef struct unk_D_800FC7D0 { /* 0x000 */ struct unk_D_800FC7D0* unk_000; diff --git a/src/fragments/1/fragment1_86920.c b/src/fragments/1/fragment1_86920.c index e006ac6..ae03319 100644 --- a/src/fragments/1/fragment1_86920.c +++ b/src/fragments/1/fragment1_86920.c @@ -7,6 +7,50 @@ typedef struct unk_func_81206FA0 { /* 0x0C */ s32 unk_0C; } unk_func_81206FA0; // size = 0x10 +typedef struct unk_D_812346EC { + /* 0x00 */ s16 unk_00; + /* 0x02 */ s16 unk_02; + /* 0x04 */ s16 unk_04; +} unk_D_812346EC;// size = 0x6 + +typedef struct unk_D_81231450 { + /* 0x00 */ s32 unk_00; + /* 0x04 */ s32 unk_04; +} unk_D_81231450;// size = 0x8 + +typedef struct unk_D_81234650 { + /* 0x00 */ s32 unk_00; + /* 0x04 */ s32 unk_04; +} unk_D_81234650;// size = 0x8 + +typedef struct unk_D_81234690 { + /* 0x00 */ u8 pad0[2]; + /* 0x02 */ s16 unk_02; + /* 0x04 */ s16 unk_04; + /* 0x06 */ s16 unk_06; + /* 0x08 */ s16 unk_08; + /* 0x0A */ s16 unk_0A; + /* 0x0C */ s16 unk_0C; + /* 0x0E */ u8 pad0E[0x2A]; +} unk_D_81234690; // size = 0x38 + +extern s32 D_812286EC; +extern s32 D_812286F0; +extern f32 D_8122AF70; +extern unk_D_81231450 D_81231450[0x640]; +extern unk_D_81234650 D_81234650[0x6]; +extern unk_func_81206FA0 D_81234680; +extern unk_D_81234690 D_81234690; +extern s32 D_812346C8; +extern s32 D_812346D4; +extern f32 D_812346D8; +extern s32 D_812346DC; +extern void* D_812346E0; +extern unk_D_812346EC D_812346EC; +extern s32 D_812346F2; +extern s32 D_81234700; +extern s32 D_812346FC; + u32 func_81206FA0(unk_func_81206FA0* arg0, s32 arg1) { s32 temp_v0; u32 temp_a2; @@ -43,11 +87,78 @@ s32 func_81207020(unk_func_81206FA0* arg0, s32 arg1) { void func_81207078(unk_func_81206FA0* arg0, s32 arg1, s32 arg2) { - arg0->unk_00 = ALIGN16(arg1); arg0->unk_04 = ALIGN16(arg1); arg0->unk_08 = (s32) (arg2 - (arg1 & 0xF)); arg0->unk_0C = 0; } +#ifdef NON_MATCHING +void func_812070A0(void) { + unk_D_81231450* var_v0; + unk_D_81234650* var_v0_2; + unk_D_812346EC* var_v1_2; + s32 temp_a0; + s32 var_a0; + u32 var_v1; + unk_D_812346EC* temp_v0; + unk_D_812346EC* var_v1_3; + unk_D_812346EC** var_s1; + + D_812346FC = 0; + temp_a0 = (s32) D_812286EC / 8; + if (temp_a0 > 0) { + var_v0 = &D_81231450[0]; + do { + var_v0 += 8; + var_v0->unk_04 = 0; + var_v0->unk_00 = 0; + } while ((u32) var_v0 < (u32)&D_81231450[temp_a0]); + } + var_v0_2 = &D_81234650[0]; + var_v1 = (u32) (&D_81234700 - (s32)&D_81234650) >> 3; + if ((s32) var_v1 >= 0) { + do { + var_v1 -= 1; + var_v0_2->unk_04 = 0; + var_v0_2->unk_00 = 0; + var_v0_2 += 8; + } while ((s32) var_v1 >= 0); + } + D_812346D8 = D_8122AF70; + D_812346DC = 0x3C; + D_81234690.unk_02 = 0xBB80U; + D_81234690.unk_04 = osAiSetFrequency(0xBB80 & 0xFFFF); + D_81234690.unk_06 = (s16) ((((s32) D_81234690.unk_02 / (s32) D_812346DC) + 0xF) & ~0xF); + var_v1_2 = &D_812346EC; + D_81234690.unk_0A = (s16) (D_81234690.unk_06 - 0x10); + D_81234690.unk_08 = (s16) (D_81234690.unk_06 + 0x10); + do { + var_v1_2 += 2; + var_v1_2->unk_02 = 0xA0; + } while ((u32) var_v1_2 < (u32) &D_812346F2); + D_812346C8 = 0; + D_812346D4 = 0; + func_81207078(&D_81234680, (s32)&D_81231450, D_812286F0); + var_s1 = D_812346E0; + do { + temp_v0 = func_81207020(&D_81234680, 0xFC0); + *var_s1 = temp_v0; + var_v1_3 = temp_v0; + var_a0 = 0; +loop_9: + var_a0 += 4; + var_v1_3->unk_02 = 0; + var_v1_3->unk_04 = 0; + var_v1_3->unk_00 = 0; + var_v1_3 += 8; + var_v1_3->unk_00 = 0; + if (var_a0 != 0x7E0) { + goto loop_9; + } + var_s1 += 4; + } while (*var_s1 != &D_812346EC); +} +#else #pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/1/fragment1_86920/func_812070A0.s") +#endif diff --git a/src/fragments/31/fragment31.h b/src/fragments/31/fragment31.h index de15ea9..00a14f3 100644 --- a/src/fragments/31/fragment31.h +++ b/src/fragments/31/fragment31.h @@ -15,8 +15,24 @@ typedef struct DisplayListState { /* 0x18 */ Gfx* gfx; } DisplayListState; // size = 0x1C +typedef struct unk_arg0_func_81002174 { + /* 0x00 */ s8 unk_00; + /* 0x01 */ s8 unk_01; + /* 0x02 */ s8 unk_02; + /* 0x03 */ s8 unk_03; + /* 0x04 */ s8 unk_04; + /* 0x05 */ s8 unk_05; + /* 0x06 */ s8 unk_06; +} unk_arg0_func_81002174; // size >= 0x7 + +typedef struct unk_arg0_func_81002260 { + /* 0x00 */ char unk00[0x1A]; + /* 0x1A */ s16 unk_1A; +} unk_arg0_func_81002260; // size >= 0x1C + void func_810007A8(unk_D_86002F58_004_000*); void func_810007F8(void); void func_81002174(unk_D_83402EE0_00A*); +void func_81002260(unk_arg0_func_81002260*, unk_arg0_func_81002174*); #endif // _FRAGMENT31_H_ diff --git a/src/fragments/31/fragment31_2558B0.c b/src/fragments/31/fragment31_2558B0.c index 846bf78..f76f768 100644 --- a/src/fragments/31/fragment31_2558B0.c +++ b/src/fragments/31/fragment31_2558B0.c @@ -1,31 +1,55 @@ #include "fragment31.h" +#include "32D10.h" #include "12D80.h" +#include "6A40.h" typedef struct unk_D_810047E0 { - /* 0x00 */ s16 unk_00; - /* 0x04 */ Vec3f unk_04; - /* 0x10 */ Vec3f unk_10; - /* 0x1C */ Vec3f unk_1C; - /* 0x28 */ s16 unk_28; + /* 0x00 */ s16 active; + /* 0x02 */ char unk02[0x2]; + /* 0x04 */ Vec3f position; + /* 0x10 */ Vec3f velocity; + /* 0x1C */ Vec3f scale; + /* 0x28 */ s16 misc; + /* 0x2A */ char unk2A[0x2]; } unk_D_810047E0; // size = 0x2C +typedef struct unk_arg2_func_81001D80 { + /* 0x00 */ s32 unk_00; + /* 0x04 */ char unk04[0x4]; + /* 0x08 */ s32 unk_08; +} unk_arg2_func_81001D80; // size = 0xC + +typedef struct unk_D_81003FE0 { + /* 0x00 */ s32 unk_00; + /* 0x04 */ s32 unk_04; + /* 0x08 */ s32 unk_08; +} unk_D_81003FE0; // size = 0xC + +extern unk_D_81003FE0 D_81003FE0[]; +extern unk_D_81003FE0 D_81003FE2[]; +extern unk_D_81003FE0 D_81003FEA[]; +extern s16 D_810040B8[18]; extern unk_D_810047E0 D_810047E0[2][10]; extern unk_D_810047E0 D_81004998[2][10]; extern s32 D_81004B50; extern s32 D_81004B54; +extern s16 D_81004B60; +extern f32 D_810040DC[12]; +extern Vec3f D_81004160; +extern s32 D_81004170; // Matching, just needs data to be done #ifdef NON_MATCHING void func_810005F0(unk_D_86002F58_004_000* arg0, s32 arg1) { u8 var_v0 = arg0->unk_0A6; - UNUSED s32 pad[2]; + s32 pad[2]; Vec3f sp50 = { 0.0f, 0.0f, 0.0f }; Vec3f sp44 = { 0.0f, 0.0f, 0.0f }; Vec3f sp38 = { 1.0f, 1.0f, 1.0f }; - UNUSED Vec3f sp2C = { 2.0f, 2.0f, 2.0f }; - UNUSED Vec3f sp20 = { 0.0f, 10.0f, 0.0f }; - UNUSED Vec3f sp14 = { 10000.0f, 10000.0f, 10000.0f }; - UNUSED Vec3f sp8 = { -10000.0f, -10000.0f, -10000.0f }; + Vec3f sp2C = { 2.0f, 2.0f, 2.0f }; + Vec3f sp20 = { 0.0f, 10.0f, 0.0f }; + Vec3f sp14 = { 10000.0f, 10000.0f, 10000.0f }; + Vec3f sp8 = { -10000.0f, -10000.0f, -10000.0f }; if (var_v0 == 0xFF) { var_v0 = 0; @@ -33,11 +57,11 @@ void func_810005F0(unk_D_86002F58_004_000* arg0, s32 arg1) { var_v0 = 0; } - D_810047E0[var_v0 & 1][arg1].unk_00 = 0; - D_810047E0[var_v0 & 1][arg1].unk_28 = 0; - D_810047E0[var_v0 & 1][arg1].unk_04 = sp50; - D_810047E0[var_v0 & 1][arg1].unk_10 = sp44; - D_810047E0[var_v0 & 1][arg1].unk_1C = sp38; + D_810047E0[var_v0 & 1][arg1].active = 0; + D_810047E0[var_v0 & 1][arg1].misc = 0; + D_810047E0[var_v0 & 1][arg1].position = sp50; + D_810047E0[var_v0 & 1][arg1].velocity = sp44; + D_810047E0[var_v0 & 1][arg1].scale = sp38; } #else #pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/31/fragment31_2558B0/func_810005F0.s") @@ -56,16 +80,351 @@ void func_810007F8(void) { D_81004B54 = 0; } +#ifdef NON_MATCHING +void func_8100080C(unk_D_810047E0* arg0) { + s32 var_s1; + Vec3f sp90; + Vec3f sp84; + Vec3f sp78; + Vec3f sp64; + f32 sp60; + f32 sp58; + f32 temp_fa1; + f32 temp_ft5; + f32 temp_fv0; + f32 temp_fv0_2; + f32 sp5C; + f32 temp_fv1; + f32 var_fs0; + f32 var_ft4; + f32 var_ft5; + f32 var_fv1; + s32 var_v0; + unk_D_810047E0* var_s0; + + var_s0 = arg0; + var_s1 = 0xA; + sp64.x = D_81004160.x; + sp64.y = D_81004160.y; + sp64.z = D_81004160.z; + guMtxXFMF(func_800123D4(-1)->mf, 0, 0, 0, &sp90.x, &sp90.y, &sp90.z); + guMtxXFMF(func_800123D4(0)->mf, 0, 0, 0, &sp84.x, &sp84.y, &sp84.z); + temp_fv1 = D_8006F09C->unk_030.x; + sp5C = D_8006F09C->unk_030.y; + sp58 = D_8006F09C->unk_030.z; + switch (D_8006F09C->unk_01A) { + case 0x6D: + case 0x6E: + var_fs0 = 0.5f; + sp64.x = 0x3F800000; + sp64.y = 0x3F800000; + sp64.z = 0x3F800000; + break; + case 0x92: + var_fs0 = 1.0f; + sp60 = temp_fv1; + sp64.x = 0x3DCCCCCD; + sp64.y = 0x3DCCCCCD; + sp64.z = 0x3DCCCCCD; + sp84.x += (f32) ((guRandom() % 10) - 5) * temp_fv1; + sp84.y += (f32) ((guRandom() % 10) - 5) * sp5C; + sp84.z += (f32) ((guRandom() % 10) - 5) * sp58; + break; + case 0x4D: + var_fs0 = 0.5f; + sp60 = temp_fv1; + sp64.x = 0x3B03126F; + sp64.y = 0x3B03126F; + sp64.z = 0x3B03126F; + sp84.x += (f32) ((guRandom() % 20) - 0xA) * temp_fv1; + sp84.y += (f32) ((guRandom() % 20) - 0xA) * sp5C; + sp84.z += (f32) ((guRandom() % 20) - 0xA) * sp58; + break; + case 0x4E: + var_fs0 = 0.5f; + sp60 = temp_fv1; + sp64.x = 0x3B03126F; + sp64.y = 0x3B03126F; + sp64.z = 0x3B03126F; + sp84.x += (f32) ((guRandom() % 20) - 0xA) * temp_fv1; + sp84.y += (f32) ((guRandom() % 10) - 5) * sp5C; + sp84.z += (f32) ((guRandom() % 20) - 0xA) * sp58; + break; + case 0x90: + var_fs0 = 0.0f; + sp60 = temp_fv1; + sp64.x = D_810040DC[0]; + sp64.y = D_810040DC[1]; + sp64.z = D_810040DC[2]; + sp84.x += (f32) ((guRandom() % 20) - 0xA) * temp_fv1; + sp84.y += (f32) ((guRandom() % 20) - 0xA) * sp5C; + sp84.z += (f32) ((guRandom() % 20) - 0xA) * sp58; + break; + case 0x86: + var_fs0 = 0.0f; + sp60 = temp_fv1; + sp64.x = D_810040DC[0]; + sp64.y = D_810040DC[1]; + sp64.z = D_810040DC[2]; + sp84.x += (f32) ((guRandom() % 60) - 0x1E) * temp_fv1; + sp84.y += (f32) ((guRandom() % 40) - 0xA) * sp5C; + sp84.z += (f32) ((guRandom() % 60) - 0x1E) * sp58; + break; + case 0x5C: + var_fs0 = 0.0f; + var_s1 = 3; + sp64.x = 0x41A00000; + sp64.y = 0x41A00000; + sp64.z = 0x41A00000; + break; + default: + var_fs0 = 0.0f; + break; + } + var_v0 = 0; +loop_11: + var_v0 += 1; + if (var_v0 < var_s1) { + if (var_s0->active == 0) { + temp_fv0 = sp84.x - sp90.x; + temp_ft5 = sp84.y - sp90.y; + sp78.x = temp_fv0; + temp_fa1 = sp84.z - sp90.z; + sp78.y = temp_ft5; + sp78.z = temp_fa1; + temp_fv0_2 = sqrtf((temp_fv0 * temp_fv0) + (temp_ft5 * temp_ft5) + (temp_fa1 * temp_fa1)); + var_fv1 = sp78.z; + var_ft4 = sp78.x; + var_ft5 = temp_ft5; + if (temp_fv0_2 > 0.0f) { + var_ft4 /= temp_fv0_2; + var_ft5 /= temp_fv0_2; + var_fv1 /= temp_fv0_2; + } + var_s0->velocity.x = (f32) (var_fs0 * var_ft4); + var_s0->velocity.y = (f32) (var_fs0 * var_ft5); + var_s0->velocity.z = (f32) (var_fs0 * var_fv1); + var_s0->position.x = sp84.x; + var_s0->position.y = sp84.y; + var_s0->position.z = sp84.z; + var_s0->scale.x = sp64.x; + var_s0->scale.y = sp64.y; + var_s0->scale.z = sp64.z; + var_s0->misc = 0; + var_s0->active = 1; + return; + } + var_s0 += 0x2C; + if (var_v0 == 0xA) { + + } else { + goto loop_11; + } + } +} +#else #pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/31/fragment31_2558B0/func_8100080C.s") +#endif +#ifdef NON_MATCHING +void func_81000E78(unk_D_810047E0* arg0) { + s16 temp_a0; + unk_D_81003FE0* var_v1; + s16 temp_v1; + s32 var_a1; + s32 var_v0; + + var_a1 = D_8006F09C->unk_040.unk_08 >> 0x10; + switch (D_8006F09C->unk_01A) { + case 0x6D: + case 0x6E: + temp_v1 = D_8006F09C->unk_040.unk_00; + temp_a0 = D_810040B8[D_81004B54 % 18]; + if (temp_v1 != 2) { + var_v0 = 0; + if (temp_v1 != 3) { + if (temp_v1 == 4) { + if (var_a1 == D_81003FE2[temp_a0].unk_00) { + func_8100080C(arg0); + return; + } + } else if (var_a1 == D_81003FE0[temp_a0].unk_00) { + func_8100080C(arg0); + return; + } + } else { + var_v1 = &D_81003FE0[temp_a0]; + do { + if (var_a1 == var_v1->unk_04) { + func_8100080C(arg0); + } + var_v0 += 2; + var_v1 += 2; + } while (var_v0 != 6); + return; + } + } else { + if (var_a1 == D_81003FEA[temp_a0].unk_00) { + func_8100080C(arg0); + return; + } + default: + return; + } + break; + case 0x92: + if ((guRandom() % 60) == 0) { + func_8100080C(arg0); + return; + } + break; + case 0x90: + if ((guRandom() % 30) == 0) { + func_8100080C(arg0); + return; + } + break; + case 0x86: + if ((guRandom() % 7) == 0) { + func_8100080C(arg0); + return; + } + break; + case 0x5C: + func_8100080C(arg0); + return; + case 0x4D: + case 0x4E: + if ((guRandom() % 7) == 0) { + func_8100080C(arg0); + } + break; + } +} +#else #pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/31/fragment31_2558B0/func_81000E78.s") +#endif +Gfx* func_810010BC(Gfx*, unk_D_810047E0*, unk_arg2_func_81001D80*, s16); #pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/31/fragment31_2558B0/func_810010BC.s") -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/31/fragment31_2558B0/func_81001D80.s") +Gfx* func_81001D80(Gfx* gfx, unk_D_810047E0* arg1, unk_arg2_func_81001D80* arg2, s16 arg3) { + s32 i; + + for (i = 0; i < 10; i++, arg1++) { + if (arg1->active == 1) { + gfx = func_810010BC(gfx, arg1, arg2, arg3); + } + } + return gfx; +} #pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/31/fragment31_2558B0/func_81001E24.s") -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/31/fragment31_2558B0/func_81002174.s") +#ifdef NON_MATCHING +void func_81002174(unk_D_83402EE0_00A* arg0) { + s32 i; + s16 var_a1; + s16 var_a2; + s16 var_a3; + u8 var_a0; + u8 var_v0; + for (i = 0; i != 10; ) { + if (D_810047E0[0][i].active == 1) { + var_v0 = 0x80; + var_a0 = D_810047E0[0][i].misc & 0x7F; + var_a1 = D_810047E0[0][i].position.x * 10.0f; + var_a2 = D_810047E0[0][i].position.y * 10.0f; + var_a3 = D_810047E0[0][i].position.z * 10.0f; + } else { + var_v0 = 0; + var_a0 = 0; + var_a1 = 0; + var_a2 = 0; + var_a3 = 0; + } + + arg0->unk_00[0] = ((var_v0 & 0x80) | (var_a0 & 0x7F)); + i++; + arg0->unk_00[1] = var_a1; + arg0->unk_00[2] = (var_a1 >> 8); + arg0->unk_00[3] = var_a2; + arg0->unk_00[4] = (var_a2 >> 8); + arg0->unk_00[5] = var_a3; + arg0->unk_00[6] = (var_a3 >> 8); + arg0 += 1; + } + + // FAKE - Stops unroll + i = 0; +} +#else +#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/31/fragment31_2558B0/func_81002174.s") +#endif + +#ifdef NON_MATCHING +void func_81002260(unk_arg0_func_81002260* arg0, unk_arg0_func_81002174* arg1) { + unk_D_810047E0* temp_v0; + f32 var_fv0; + s16 var_a2; + s16 var_t0; + s32 temp_a0; + s32 var_a0; + s32 i; + u8 temp_a3; + unk_arg0_func_81002174* temp_a1; + + for (i = 0; i < 10; i++) { + temp_a3 = arg1->unk_00; + temp_a1 = arg1 + 1; + if (!(temp_a3 & 0x80)) { + D_810047E0[0][i].active = 0; + var_a0 = 0; + var_a2 = 0; + var_t0 = 0; + arg1 = temp_a1 + 6; + } else { + D_810047E0[0][i].active = 1; + temp_a0 = ((arg1->unk_01 | (temp_a1->unk_01 << 8)) & 0xFFFF) << 0x10; + arg1 = temp_a1 + 6; + var_a0 = temp_a0 >> 0x10; + var_a2 = (temp_a1->unk_02 | (temp_a1->unk_03 << 8)) & 0xFFFF; + var_t0 = (temp_a1->unk_04 | (temp_a1->unk_05 << 8)) & 0xFFFF; + } + D_810047E0[0][i].misc = (s16) (temp_a3); + switch (arg0->unk_1A) { + case 0x92: + var_fv0 = ((f32) D_810047E0[0][i].misc * 0.005f) + 0.1f; + break; + case 0x4D: + case 0x4E: + var_fv0 = ((f32) D_810047E0[0][i].misc * 0.005f) + 0.002f; + break; + case 0x86: + case 0x90: + var_fv0 = D_810040DC[D_810047E0[0][i].misc % 12]; + break; + case 0x6D: + case 0x6E: + var_fv0 = ((f32) D_810047E0[0][i].misc * 0.1f) + 1.0f; + break; + case 0x5C: + var_fv0 = 20.0f; + break; + default: + var_fv0 = 1.0f; + break; + } + // var_v1 += 0x2C; + temp_v0->scale.x = var_fv0; + temp_v0->scale.y = var_fv0; + temp_v0->scale.z = var_fv0; + temp_v0->position.x = (f32) ((f32) var_a0 / 10.0f); + temp_v0->position.y = (f32) ((f32) var_a2 / 10.0f); + temp_v0->position.z = (f32) ((f32) var_t0 / 10.0f); + }; +} +#else #pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/31/fragment31_2558B0/func_81002260.s") +#endif diff --git a/src/fragments/31/fragment31_258080.c b/src/fragments/31/fragment31_258080.c index 4470ba6..7953f51 100644 --- a/src/fragments/31/fragment31_258080.c +++ b/src/fragments/31/fragment31_258080.c @@ -1,7 +1,9 @@ #include "fragment31.h" #include "src/fragments/7/fragment7.h" #include "src/fragments/8/fragment8.h" +#include "src/fragments/50/fragment50.h" #include "src/6A40.h" +#include "src/12D80.h" #include "src/32D10.h" typedef struct { @@ -12,12 +14,14 @@ typedef struct { } Keyframe; // size = 0x08 extern Keyframe* D_8100419C[]; -extern s32 D_810041D0; +extern s32 D_810041D0[20]; +extern char D_810047D0[3]; extern s32 D_81004B70; extern s32 D_81004B80; extern s32 D_81004B90; extern s32 D_81004BA0; extern s32 D_81004BB0; +extern char D_81004BB8[0x28]; #ifdef NON_MATCHING void func_81002DC0(Gfx* gfx, s32 arg1, s32 arg2) { @@ -309,8 +313,50 @@ s32 func_81003A24(s8* arg0) { return var_v1; } -void func_81003A54(Gfx*); +#ifdef NON_MATCHING +void func_81003A54(Gfx* gfx) { + u8 sp4D; + char* sp34; + Mtx* sp30; + s32 sp2C; + u8 temp_t0; + u8 var_v1; + + temp_t0 = D_800AF770[(D_8006F09C->unk_0A6 % 5) & 0xFF]; + switch (D_81004BB0) { + case 0: + var_v1 = (((s32) (temp_t0 + 1) / 100) + 0x10) & 0xFF; + break; + case 1: + var_v1 = (((s32) ((s32) (temp_t0 + 1) % 100) / 10) + 0x10) & 0xFF; + break; + case 2: + var_v1 = (((s32) (temp_t0 + 1) % 10) + 0x10) & 0xFF; + break; + default: + sp34 = func_8002D7C0(0, 0, D_8267E760, temp_t0);; + sprintf(D_81004BB8, D_810047D0, sp34); + sp4D = func_8001E730((u8) D_81004BB8[(D_81004BB0 - 3) & 0xFFFF]); + sp2C = 0xA - func_81003A24((s8*)sp34); + sp30 = func_80005F5C(0x40);; + guTranslate(sp30, (f32) sp2C * 32.0f, 0.0f, 0.0f); + var_v1 = sp4D; + { Gfx *_gfx = (Gfx *)(gfx++); _gfx->words.w0 = 0xDA380001; _gfx->words.w1 = sp30; } + break; + } + { Gfx *_gfx = (Gfx *)(gfx++); _gfx->words.w0 = 0xFD6800FF; _gfx->words.w1 = Util_ConvertAddrToVirtAddr(D_3000000[((var_v1 & 0xF) * 0x10) + (((s32) (var_v1 & 0xF0) >> 4) << 0xC)]); } + { Gfx *_gfx = (Gfx *)(gfx++); _gfx->words.w0 = 0xF5680600; _gfx->words.w1 = 0x07094250; } + { Gfx *_gfx = (Gfx *)(gfx++); _gfx->words.w0 = 0xE6000000; _gfx->words.w1 = 0; } + { Gfx *_gfx = (Gfx *)(gfx++); _gfx->words.w0 = 0xF4000000; _gfx->words.w1 = 0x07040040; } + { Gfx *_gfx = (Gfx *)(gfx++); _gfx->words.w0 = 0xE7000000; _gfx->words.w1 = 0; } + { Gfx *_gfx = (Gfx *)(gfx++); _gfx->words.w0 = 0xF5680600; _gfx->words.w1 = 0x94250; } + { Gfx *_gfx = (Gfx *)(gfx++); _gfx->words.w0 = 0xF2000000; _gfx->words.w1 = 0x40040; } + { Gfx *_gfx = (Gfx *)(gfx++); _gfx->words.w0 = 0xDF000000; _gfx->words.w1 = 0; } + D_81004BB0 += 1; +} +#else #pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/31/fragment31_258080/func_81003A54.s") +#endif void func_81003CF0(s32 arg0, DisplayListState* state) { Gfx* gfx; diff --git a/src/fragments/50/fragment50.c b/src/fragments/50/fragment50.c index a02fe45..4de1d45 100644 --- a/src/fragments/50/fragment50.c +++ b/src/fragments/50/fragment50.c @@ -77,7 +77,6 @@ static s32 D_8267E750; static s32 D_8267E754; static s32 D_8267E758; static char** D_8267E75C; -static char** D_8267E760; static u32 D_82603E80[] = { 0xA4CAA4DE, 0xA4A80000, 0xA5ECA5D9, 0xA5EB0000, 0xA4AAA4E4, 0x00000000, 0xA4C7A4F3, 0xA4C9A4A6, 0xA4A4A4EA, diff --git a/src/fragments/50/fragment50.h b/src/fragments/50/fragment50.h index b0e24a6..49e7a8a 100644 --- a/src/fragments/50/fragment50.h +++ b/src/fragments/50/fragment50.h @@ -3,6 +3,8 @@ #include "global.h" +extern char** D_8267E760; + void func_82600020(void); s32 func_82600094(s8* arg0, s8* arg1); s32 func_826000D8(void);