kawa/banjo-kazooie
1
0
Fork 0
Code Issues Actions Packages Projects Releases Wiki Activity

documented volatile flag functions and enums and some Actor struct members

Browse Source
This commit is contained in:
mariob92
2024-09-08 12:22:27 +02:00
parent 347c3edcdf
commit 615e2bda33
111 changed files with 584 additions and 549 deletions
Download Patch File Download Diff File Expand all files Collapse all files

139
src/core2/code_98CB0.c
View File

@@ -6,10 +6,10 @@ void func_8031FFAC(void);
void fileProgressFlag_set(s32 index, s32 set);
s32 bitfield_get_bit(u8 *array, s32 index);
s32 bitfield_get_n_bits(u8 *array, s32 offset, s32 numBits);
void setBitToArray(u8 *array, s32 index, s32 set);
void func_803201C8(u8 *array, s32 startIndex, s32 set, s32 length);
void func_8032048C(void);
void func_803204E4(s32 arg0, s32 arg1);
void bitfield_set_bit(u8 *array, s32 index, s32 set);
void bitfield_set_n_bits(u8 *array, s32 startIndex, s32 set, s32 length);
void volatileFlag_clear(void);
void volatileFlag_set(s32 arg0, s32 arg1);
s32 fileProgressFlag_getN(s32 offset, s32 numBits);
void func_8031CE70(f32 *arg0, s32 arg1, s32 arg2);
void ml_vec3h_to_vec3f(f32 *, s32);
@@ -22,22 +22,22 @@ void func_80256E24(f32 *, f32, f32, f32, f32, f32);
/* .data */
s32 D_8036DDF0 = 0x24;
s32 gVolatileFlagsSize = 0x24; // sizeof(gVolatileFlags)
/* .bss */
struct {
s32 unk0;
s32 unk4;
u8 unk8[0x25];
} D_803831A0;
} gFileProgressFlags;
struct {
s32 unk0;
s32 unk4;
u8 unk8[0x19];
} D_803831D0;
} gVolatileFlags;
u8 D_803831F8[0x21]; //copy of D_803831D0
u8 glVolatileFlagsCopy[0x21]; //copy of gVolatileFlags
/* .code */
@@ -53,16 +53,16 @@ void func_8031FC40(void) {
u32 v1;
//obsucre address
t0 = (((s32)&D_803831A0.unk8 & 0xE0000000) >> 15) +
(((s32)&D_803831A0.unk8 & 0x1FC00000) >> 22) +
(((s32)&D_803831A0.unk8 & 0x00300000) << 10) +
(((s32)&D_803831A0.unk8 & 0x000F0000) << 7) +
(((s32)&D_803831A0.unk8 & 0x0000E000) << 14) +
(((s32)&D_803831A0.unk8 & 0x00001800) >> 4) +
(((s32)&D_803831A0.unk8 & 0x00000780) << 10) +
(((s32)&D_803831A0.unk8 & 0x00000060) << 4) +
(((s32)&D_803831A0.unk8 & 0x00000018) << 18) +
(((s32)&D_803831A0.unk8 & 0x00000007) << 11);
t0 = (((s32)&gFileProgressFlags.unk8 & 0xE0000000) >> 15) +
(((s32)&gFileProgressFlags.unk8 & 0x1FC00000) >> 22) +
(((s32)&gFileProgressFlags.unk8 & 0x00300000) << 10) +
(((s32)&gFileProgressFlags.unk8 & 0x000F0000) << 7) +
(((s32)&gFileProgressFlags.unk8 & 0x0000E000) << 14) +
(((s32)&gFileProgressFlags.unk8 & 0x00001800) >> 4) +
(((s32)&gFileProgressFlags.unk8 & 0x00000780) << 10) +
(((s32)&gFileProgressFlags.unk8 & 0x00000060) << 4) +
(((s32)&gFileProgressFlags.unk8 & 0x00000018) << 18) +
(((s32)&gFileProgressFlags.unk8 & 0x00000007) << 11);
//unobscure address
t1 = ((t0 & 0x1E0600) << 0xB) | ((s32) (t0 & 0x603800) / 8);
@@ -79,7 +79,7 @@ void func_8031FC40(void) {
v0 = (((v0 - ptr[v1]) & 0x1F) << 0xF) ^ ((ptr[v1]* 0x1B) + (v0 >> 0xB));
}
scrambled_ptr = (s32 *) ((((s32) &D_803831A0 & 0x55555555) << 1) + (((s32) &D_803831A0 & 0xAAAAAAAA) >> 1));
scrambled_ptr = (s32 *) ((((s32) &gFileProgressFlags & 0x55555555) << 1) + (((s32) &gFileProgressFlags & 0xAAAAAAAA) >> 1));
unscrambled_ptr = (s32 *) ((((s32) scrambled_ptr & 0x55555555) << 1) | (((s32) scrambled_ptr & 0xAAAAAAAA) >> 1));
*unscrambled_ptr = v0;
}
@@ -92,7 +92,7 @@ u32 func_8031FE40(void) {
var_v1 = 0xDE1C05;
var_v0 = 0x25;
obscured_addr = (u8*)OBSCURE(&D_803831A0.unk8[0]);
obscured_addr = (u8*)OBSCURE(&gFileProgressFlags.unk8[0]);
for(var_a2 = 0; var_a2 < var_v0; var_a2++){
var_v1 += ((var_v1 % 4) + var_a2) * obscured_addr[var_a2];
}
@@ -101,16 +101,16 @@ u32 func_8031FE40(void) {
void func_8031FEC0(void) {
u32 *obscured_addr;
obscured_addr = (u32*)OBSCURE(&D_803831A0.unk4);
obscured_addr = (u32*)OBSCURE(&gFileProgressFlags.unk4);
*obscured_addr = func_8031FE40();
}
bool fileProgressFlag_get(enum file_progress_e index) {
return bitfield_get_bit(D_803831A0.unk8, index);
return bitfield_get_bit(gFileProgressFlags.unk8, index);
}
s32 fileProgressFlag_getN(s32 offset, s32 numBits) {
return bitfield_get_n_bits(D_803831A0.unk8, offset, numBits);
return bitfield_get_n_bits(gFileProgressFlags.unk8, offset, numBits);
}
s32 fileProgressFlag_getAndSet(s32 index, s32 set) {
@@ -125,27 +125,27 @@ void func_8031FFAC(void) {
s32 i;
for (i = 0; i < 37; i++) {
D_803831A0.unk8[i] = 0;
gFileProgressFlags.unk8[i] = 0;
}
func_8031FC40();
func_8031FEC0();
}
void fileProgressFlag_set(s32 index, s32 set) {
setBitToArray(D_803831A0.unk8, index, set);
bitfield_set_bit(gFileProgressFlags.unk8, index, set);
func_8031FC40();
func_8031FEC0();
}
void fileProgressFlag_setN(s32 startIndex, s32 set, s32 length) {
func_803201C8(D_803831A0.unk8, startIndex, set, length);
bitfield_set_n_bits(gFileProgressFlags.unk8, startIndex, set, length);
func_8031FC40();
func_8031FEC0();
}
void progressflags_getSizeAndPtr(s32 *size, u8 **addr) {
void fileProgressFlag_getSizeAndPtr(s32 *size, u8 **addr) {
*size = 0x25;
*addr = D_803831A0.unk8;
*addr = gFileProgressFlags.unk8;
}
// Returns a single bit from a byte array
@@ -171,7 +171,7 @@ s32 bitfield_get_n_bits(u8 *array, s32 offset, s32 numBits) {
}
// Sets or clears a single bit in a byte array
void setBitToArray(u8 *array, s32 index, s32 set) {
void bitfield_set_bit(u8 *array, s32 index, s32 set) {
if (set) {
array[index / 8] |= (1 << (index & 7));
} else {
@@ -180,21 +180,21 @@ void setBitToArray(u8 *array, s32 index, s32 set) {
}
// Sets or clears a range of bits in a byte array
void func_803201C8(u8 *array, s32 startIndex, s32 set, s32 length) {
void bitfield_set_n_bits(u8 *array, s32 startIndex, s32 set, s32 length) {
s32 i;
for (i = 0; i < length; i++) {
setBitToArray(array, startIndex + i, (1 << i) & set);
bitfield_set_bit(array, startIndex + i, (1 << i) & set);
}
}
s32 func_80320240(void){return 1;}
s32 dummy_func_80320240(void){return 1;}
s32 func_80320248(void){return 1;}
s32 dummy_func_80320248(void){return 1;}
u32 func_80320250(void) {
u32 checksum = 0x6CE9E91F;
u8 *obscured_addr = (u8*)OBSCURE(&D_803831D0.unk8[0]);
u8 *obscured_addr = (u8*)OBSCURE(&gVolatileFlags.unk8[0]);
s32 len = 25;
u32 i;
@@ -207,7 +207,7 @@ u32 func_80320250(void) {
}
void func_803202D0(void) {
s32 addr = (s32) &D_803831D0.unk0;
s32 addr = (s32) &gVolatileFlags.unk0;
addr ^= 0x7EDDF5F4;
addr ^= 0x7BEF9D80;
addr ^= 0x5326874;
@@ -215,7 +215,7 @@ void func_803202D0(void) {
}
s32 func_80320320(void) {
s32 addr = (s32) &D_803831D0.unk8[0];
s32 addr = (s32) &gVolatileFlags.unk8[0];
s32 checksum = 0x281E421C;
s32 len = 25;
s32 scrambled;
@@ -238,44 +238,44 @@ s32 func_80320320(void) {
}
void func_803203A0(void) {
u32 *obscured_addr = (u32*)OBSCURE(&D_803831D0.unk4);
u32 *obscured_addr = (u32*)OBSCURE(&gVolatileFlags.unk4);
*obscured_addr = func_80320320();
}
s32 func_803203FC(s32 index) {
return bitfield_get_bit(D_803831D0.unk8, index);
s32 volatileFlag_get(s32 index) {
return bitfield_get_bit(gVolatileFlags.unk8, index);
}
void func_80320424(s32 index, s32 numBits) {
bitfield_get_n_bits(D_803831D0.unk8, index, numBits);
void volatileFlag_getN(s32 index, s32 numBits) {
bitfield_get_n_bits(gVolatileFlags.unk8, index, numBits);
}
s32 func_80320454(s32 index, s32 arg1) {
s32 volatileFlag_getAndSet(s32 index, s32 arg1) {
s32 temp_v0;
temp_v0 = func_803203FC(index);
func_803204E4(index, arg1);
temp_v0 = volatileFlag_get(index);
volatileFlag_set(index, arg1);
return temp_v0;
}
void func_8032048C(void) {
void volatileFlag_clear(void) {
s32 i;
for (i = 0; i < 25; i++) {
D_803831D0.unk8[i] = 0;
gVolatileFlags.unk8[i] = 0;
}
func_803202D0();
func_803203A0();
}
void func_803204E4(s32 index, s32 set) {
setBitToArray(D_803831D0.unk8, index, set);
void volatileFlag_set(s32 index, s32 set) {
bitfield_set_bit(gVolatileFlags.unk8, index, set);
func_803202D0();
func_803203A0();
}
void func_80320524(s32 startIndex, s32 set, s32 length) {
func_803201C8(D_803831D0.unk8, startIndex, set, length);
void volatileFlag_setN(s32 startIndex, s32 set, s32 length) {
bitfield_set_n_bits(gVolatileFlags.unk8, startIndex, set, length);
func_803202D0();
func_803203A0();
}
@@ -285,7 +285,7 @@ s32 func_8032056C(void) {
s32 temp_a1;
s32 temp_a1_2;
s32 phi_t9;
s32 addr = (s32)&D_803831D0;
s32 addr = (s32)&gVolatileFlags;
s32 temp_v1;
temp_v1 = ((addr & 0xE0000000) >> 15) +
@@ -312,31 +312,32 @@ s32 func_80320708(void) {
u16 temp_t6;
s32 addr;
temp_t6 = ((s32) &D_803831D0.unk4 >> 0x10);
addr = (s32) &D_803831D0.unk4 ^ temp_t6;
temp_t6 = ((s32) &gVolatileFlags.unk4 >> 0x10);
addr = (s32) &gVolatileFlags.unk4 ^ temp_t6;
return func_80320320() == *(s32*)(addr ^ temp_t6);
}
void func_80320748(void) {
s32 var_v0;
u8 *var_a0;
u8 *var_a1;
void volatileFlag_backupAll(void) {
s32 i;
u8 *dst;
u8 *src;
var_a1 = &D_803831D0;
var_a0 = D_803831F8;
for(var_v0 = 0; var_v0 < D_8036DDF0; var_v0++){
var_a0[var_v0] = var_a1[var_v0];
src = (u8 *) &gVolatileFlags;
dst = glVolatileFlagsCopy;
for(i = 0; i < gVolatileFlagsSize; i++){
dst[i] = src[i];
}
}
void func_80320798(void) {
s32 var_v0;
u8 *var_a0;
u8 *var_a1;
void volatileFlag_restoreAll(void) {
s32 i;
u8 *dst;
u8 *src;
var_a1 = D_803831F8;
var_a0 = &D_803831D0;
for(var_v0 = 0; var_v0 < D_8036DDF0; var_v0++){
var_a0[var_v0] = var_a1[var_v0];
src = glVolatileFlagsCopy;
dst = (u8 *) &gVolatileFlags;
for(i = 0; i < gVolatileFlagsSize; i++) {
dst[i] = src[i];
}
}