falso
/
mm
mirror of https://github.com/zeldaret/mm.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add current missing functions prototypes (#181) 

* First bash

* Another batch

* Another bunch

* Update actorfixer

* run format

* Apply suggestions from code review

Co-authored-by: engineer124 <47598039+engineer124@users.noreply.github.com>

* Suggestion

* context renaming

* Update include/functions.h

Co-authored-by: engineer124 <47598039+engineer124@users.noreply.github.com>

* Fix renamings

* fix

Co-authored-by: engineer124 <47598039+engineer124@users.noreply.github.com>
This commit is contained in:
Anghelo Carvajal 2021-06-17 08:54:18 -04:00 committed by GitHub
parent 52d36d7373
commit 3098abd4f6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
28 changed files with 436 additions and 401 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

281
include/functions.h
View File

@ -439,7 +439,7 @@ void osViSetEvent(OSMesgQueue* mq, OSMesg m, u32 retraceCount);
s32 osPfsIsPlug(OSMesgQueue* queue, u8* pattern);
// void func_800925CC(void);
// void func_80092680(void);
// void __osVoiceGetStatus(void);
s32 __osVoiceGetStatus(OSMesgQueue* mq, s32 port, u8* status);
OSPiHandle* osCartRomInit(void);
// void func_80092A80(void);
// s32 __osPfsSelectBank(OSPfs* pfs, UNK_TYPE4 param_2);
@ -563,7 +563,7 @@ void func_800AE5A0(GlobalContext* globalCtx);
// void func_800AE5E4(void);
void func_800AE778(GlobalContext* globalCtx, Color_RGBA8* color, s16 param_3, s16 param_4);
void func_800AE8EC(GlobalContext* globalCtx);
void func_800AE930(CollisionContext* bgCtxt, s32 param_2, float* param_3, f32 param_4, s16 param_5, CollisionPoly* param_6, s32 param_7);
void func_800AE930(CollisionContext* colCtx, s32 param_2, float* param_3, f32 param_4, s16 param_5, CollisionPoly* param_6, s32 param_7);
// void func_800AEF44(void);
void EffectTireMark_InitParticle(EffTireMarkParticle* particle);
void EffectTireMark_Init(EffTireMarkParams* params, EffTireMarkInit* init);
@ -643,16 +643,20 @@ void EffectSsKiraKira_SpawnDispersed (GlobalContext * globalCtx, Vec3f * pos, Ve
// void EffectSsGSpk_SpawnRandColor(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE2 param_6, UNK_TYPE2 param_7);
// void EffectSsGSpk_SpawnSmall(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7);
// void EffectSsDFire_Spawn(UNK_TYPE4 uParm1, Vec3f* pzParm2, Vec3f* pzParm3, Vec3f* pzParm4, UNK_TYPE2 param_5, UNK_TYPE2 param_6, UNK_TYPE2 param_7, UNK_TYPE2 param_8, UNK_TYPE2 param_9, UNK_TYPE4 param_10);
// void EffectSsBubble_Spawn(UNK_TYPE4 uParm1, Vec3f* pzParm2, UNK_TYPE4 uParm3, UNK_TYPE4 uParm4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
void EffectSsBubble_Spawn(GlobalContext* globalCtx, Vec3f* pos, f32 yPosOffset, f32 yPosRandScale, f32 xzPosRandScale,
f32 scale);
void EffectSsGRipple_Spawn(GlobalContext* globalCtx, Vec3f* pos, s16 radius, s16 radiusMax, s16 life);
void EffectSsGSplash_Spawn(GlobalContext* globalCtx, Vec3f* pos, Color_RGBA8* primColor, Color_RGBA8* envColor,
s16 type, s16 scale);
// void EffectSsGFire_Spawn(UNK_TYPE4 uParm1, Vec3f* pzParm2);
// void EffectSsLightning_Spawn(UNK_TYPE4 uParm1, Vec3f* pzParm2, Color_RGBA8* pzParm3, Color_RGBA8* pzParm4, UNK_TYPE2 param_5, UNK_TYPE2 param_6, UNK_TYPE2 param_7, UNK_TYPE2 param_8);
// void EffectSsDtBubble_SpawnColorProfile(UNK_TYPE4 param_1, Vec3f* param_2, Vec3f* param_3, Vec3f* param_4, UNK_TYPE2 param_5, UNK_TYPE2 param_6, UNK_TYPE2 param_7, UNK_TYPE2 param_8);
// void EffectSsDtBubble_SpawnCustomColor(UNK_TYPE4 uParm1, Vec3f* pzParm2, Vec3f* pzParm3, Vec3f* pzParm4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE2 param_7, UNK_TYPE2 param_8, UNK_TYPE2 param_9);
// void EffectSsHahen_Spawn(UNK_TYPE4 uParm1, Vec3f* pzParm2, Vec3f* pzParm3, Vec3f* pzParm4, UNK_TYPE2 param_5, UNK_TYPE2 param_6, UNK_TYPE2 param_7, UNK_TYPE2 param_8, UNK_TYPE4 param_9);
// void EffectSsHahen_SpawnBurst(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE2 param_5, UNK_TYPE2 param_6, UNK_TYPE2 param_7, UNK_TYPE2 param_8, UNK_TYPE2 param_9, UNK_TYPE4 param_10);
void EffectSsDtBubble_SpawnCustomColor(GlobalContext* globalCtx, Vec3f* pos, Vec3f* velocity, Vec3f* accel,
Color_RGBA8* primColor, Color_RGBA8* envColor, s16 scale, s16 life, s16 randXZ);
void EffectSsHahen_Spawn(GlobalContext* globalCtx, Vec3f* pos, Vec3f* velocity, Vec3f* accel, s16 unused, s16 scale,
s16 objId, s16 life, Gfx* dList);
void EffectSsHahen_SpawnBurst(GlobalContext* globalCtx, Vec3f* pos, f32 burstScale, s16 unused, s16 scale,
s16 randScaleRange, s16 count, s16 objId, s16 life, Gfx* dList);
// void func_800B2364(void);
// void EffectSsStick_Spawn(UNK_TYPE4 uParm1, UNK_PTR puParm2, UNK_TYPE2 uParm3);
// void EffectSsSibuki_Spawn(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE2 param_5, UNK_TYPE2 param_6, UNK_TYPE2 param_7);
@ -672,7 +676,8 @@ void EffectSsKakera_Spawn(GlobalContext* globalCtx, Vec3f* pos, Vec3f* velocity,
// void EffectSsEnIce_SpawnFlyingVec3f(UNK_TYPE4 uParm1, Actor* pzParm2, Vec3f* pzParm3, Color_RGBA8* pzParm4, Color_RGBA8* param_5, UNK_TYPE4 param_6);
// void func_800B2B44(void);
// void func_800B2B7C(void);
// void EffectSsEnIce_Spawn(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7, UNK_TYPE4 param_8);
void EffectSsEnIce_Spawn(GlobalContext* globalCtx, Vec3f* pos, f32 scale, Vec3f* velocity, Vec3f* accel,
Color_RGBA8* primColor, Color_RGBA8* envColor, s32 life);
// void EffectSsFireTail_Spawn(UNK_TYPE4 uParm1, UNK_TYPE4 uParm2, Vec3f* pzParm3, UNK_TYPE4 uParm4, Vec3f* param_5, UNK_TYPE2 param_6, Color_RGBA8* param_7, Color_RGBA8* param_8, UNK_TYPE2 param_9, UNK_TYPE2 param_10, UNK_TYPE4 param_11);
// void EffectSsFireTail_SpawnFlame(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE2 param_5, UNK_TYPE4 param_6);
// void EffectSsFireTail_SpawnFlameOnPlayer(void);
@ -681,17 +686,18 @@ void EffectSsKakera_Spawn(GlobalContext* globalCtx, Vec3f* pos, Vec3f* velocity,
// void EffectSsExtra_Spawn(UNK_TYPE4 uParm1, Vec3f* pzParm2, Vec3f* pzParm3, Vec3f* pzParm4, UNK_TYPE2 param_5, UNK_TYPE2 param_6);
void EffectSsDeadDb_Spawn(GlobalContext* globalCtx, Vec3f* pos, Vec3f* velocity, Vec3f* accel, Color_RGBA8* prim, Color_RGBA8* env,
s16 scale, s16 scaleStep, s32 unk);
// void func_800B3030(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE2 param_5, UNK_TYPE2 param_6, UNK_TYPE4 param_7);
void func_800B3030(GlobalContext* globalCtx, Vec3f* pos, Vec3f* velocity, Vec3f* accel, s16 scale, s16 scaleStep,
s32 colorIndex);
// void EffectSsDeadDd_Spawn(UNK_TYPE4 uParm1, Vec3f* pzParm2, Vec3f* pzParm3, Vec3f* pzParm4, UNK_TYPE1* param_5, UNK_TYPE1* param_6, UNK_TYPE2 param_7, UNK_TYPE2 param_8, UNK_TYPE2 param_9, UNK_TYPE4 param_10);
// void EffectSsDeadDs_Spawn(UNK_TYPE4 uParm1, Vec3f* pzParm2, Vec3f* pzParm3, Vec3f* pzParm4, UNK_TYPE2 param_5, UNK_TYPE2 param_6, UNK_TYPE2 param_7, UNK_TYPE4 param_8);
// void func_800B31BC(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE2 param_5, UNK_TYPE4 param_6);
// void EffectSsIceSmoke_Spawn(UNK_TYPE4 uParm1, Vec3f* pzParm2, Vec3f* pzParm3, Vec3f* pzParm4, UNK_TYPE2 param_5);
void EffectSsIceSmoke_Spawn(GlobalContext* globalCtx, Vec3f* pos, Vec3f* velocity, Vec3f* accel, s16 scale);
// void EffectSsIceBlock_Spawn(UNK_TYPE4 uParm1, Vec3f* pzParm2, Vec3f* pzParm3, Vec3f* pzParm4, UNK_TYPE2 param_5);
void func_800B32D0(GameState* ctxt);
void func_800B32D0(GameState* gamestate);
// void func_800B3644(void);
void DLF_LoadGameState(GameStateOverlay* gameState);
void DLF_FreeGameState(GameStateOverlay* gameState);
void Actor_PrintLists(ActorContext* actCtxt);
void Actor_PrintLists(ActorContext* actorCtx);
void ActorShape_Init(ActorShape* actorShape, f32 yOffset, ActorShadowFunc func, f32 scale);
void ActorShadow_Draw(Actor* actor, Lights* mapper, GlobalContext* globalCtx, Gfx* displayList, Color_RGBA8* color);
void func_800B3FC0(Actor* actor, Lights* mapper, GlobalContext* globalCtx);
@ -707,8 +713,8 @@ void func_800B4EDC(GlobalContext* globalCtx, Vec3f* pzParm2, Vec3f* pzParm3, f32
// void func_800B4F40(TargetContext* targetContext, s32 param_2, UNK_TYPE4 param_3, UNK_TYPE4 param_4, UNK_TYPE4 param_5);
void func_800B4F78(TargetContext* targetContext, u8 type, GlobalContext* globalCtx);
void func_800B5040(TargetContext* targetContext, Actor* actor, u8 type, GlobalContext* globalCtx);
void Actor_TargetContextInit(TargetContext* targetCtxt, Actor* actor, GlobalContext* globalCtx);
void func_800B5208(TargetContext* targetCtxt, GlobalContext* globalCtx);
void Actor_TargetContextInit(TargetContext* targetCtx, Actor* actor, GlobalContext* globalCtx);
void func_800B5208(TargetContext* targetCtx, GlobalContext* globalCtx);
void func_800B5814(TargetContext* targetContext, ActorPlayer* player, Actor* param_3, GlobalContext* globalCtx);
u32 Flags_GetSwitch(GlobalContext* globalCtx, s32 flag);
void Actor_SetSwitchFlag(GlobalContext* globalCtx, s32 flag);
@ -725,12 +731,12 @@ void Actor_SetRoomClearedTemp(GlobalContext* globalCtx, u32 roomNumber);
void Actor_UnsetRoomClearedTemp(GlobalContext* globalCtx, u32 roomNumber);
u32 Actor_GetCollectibleFlag(GlobalContext* globalCtx, s32 index);
void Actor_SetCollectibleFlag(GlobalContext* globalCtx, s32 index);
void Actor_TitleCardContextInit(GlobalContext* globalCtx, TitleCardContext* titleCtxt);
void Actor_TitleCardCreate(GlobalContext* globalCtx, TitleCardContext* titleCtxt, u32 texture, s16 param_4, s16 param_5, u8 param_6, u8 param_7);
void Actor_TitleCardContextInit(GlobalContext* globalCtx, TitleCardContext* titleCardCtx);
void Actor_TitleCardCreate(GlobalContext* globalCtx, TitleCardContext* titleCardCtx, u32 texture, s16 param_4, s16 param_5, u8 param_6, u8 param_7);
// void Actor_Nop800B5E50(UNK_TYPE4 param_1, UNK_TYPE4 param_2, UNK_TYPE4 param_3, UNK_TYPE4 param_4);
void Actor_TitleCardUpdate(GlobalContext* globalCtx, TitleCardContext* titleCtxt);
void Actor_TitleCardDraw(GlobalContext* globalCtx, TitleCardContext* titleCtxt);
// UNK_TYPE4 func_800B6434(GlobalContext* globalCtx, TitleCardContext* titleCtxt);
void Actor_TitleCardUpdate(GlobalContext* globalCtx, TitleCardContext* titleCardCtx);
void Actor_TitleCardDraw(GlobalContext* globalCtx, TitleCardContext* titleCardCtx);
// UNK_TYPE4 func_800B6434(GlobalContext* globalCtx, TitleCardContext* titleCardCtx);
// UNK_TYPE4 func_800B645C(void);
void func_800B6468(GlobalContext* globalCtx);
void func_800B6474(GlobalContext* globalCtx);
@ -825,7 +831,7 @@ UNK_TYPE4 func_800B8A1C(Actor* actor, GlobalContext* globalCtx, s32 iParm3, f32
// void func_800B8B84(void);
// void func_800B8BB0(void);
// void func_800B8BD0(void);
// void func_800B8BFC(void);
s32 func_800B8BFC(Actor* actor, GlobalContext* globalCtx);
// void func_800B8C20(void);
void func_800B8C50(Actor* actor, GlobalContext* globalCtx);
// void func_800B8C78(void);
@ -836,20 +842,21 @@ void func_800B8C50(Actor* actor, GlobalContext* globalCtx);
void func_800B8D98(GlobalContext* globalCtx, Actor* actor, f32 param_3, s16 param_4, f32 param_5);
// void func_800B8DD4(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
// void func_800B8E1C(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5);
// void func_800B8E58(void);
void Audio_PlayActorSound2(Actor* actor, s16 sfxId);
void func_800B8E58(Actor* actor, u16 sfxId);
void Audio_PlayActorSound2(Actor* actor, u16 sfxId);
// void func_800B8FC0(void);
void func_800B9010(Actor* actor, s16 sfxId);
void func_800B8F98(Actor* actor, u16 sfxId);
void func_800B9010(Actor* actor, u16 sfxId);
// void func_800B9038(void);
// void func_800B9084(void);
void func_800B9098(Actor* actor);
s32 func_800B90AC(GlobalContext* globalCtx, Actor* actor, UNK_TYPE arg2, UNK_TYPE arg3, UNK_TYPE arg4);
// void func_800B90F4(void);
void func_800B9120(ActorContext* actCtxt);
// void Actor_Init(GlobalContext* globalCtx, ActorContext* actCtxt, UNK_TYPE4 uParm3);
void func_800B9334(GlobalContext* globalCtx, ActorContext* actCtxt);
void func_800B9120(ActorContext* actorCtx);
// void Actor_Init(GlobalContext* globalCtx, ActorContext* actorCtx, UNK_TYPE4 uParm3);
void func_800B9334(GlobalContext* globalCtx, ActorContext* actorCtx);
Actor* Actor_UpdateActor(s800B948C* params);
void Actor_UpdateAll(GlobalContext* globalCtx, ActorContext* actCtxt);
void Actor_UpdateAll(GlobalContext* globalCtx, ActorContext* actorCtx);
void Actor_DrawActor(GlobalContext* globalCtx, Actor* actor);
void func_800B9D1C(Actor* actor);
void Actor_DrawAllSetup(GlobalContext* globalCtx);
@ -858,21 +865,21 @@ s32 Actor_RecordUndrawnActor(GlobalContext* globalCtx, Actor* actor);
void func_800B9EF4(GlobalContext* globalCtx, s32 numActors, Actor** actors);
s32 func_800BA2D8(GlobalContext* globalCtx, Actor* actor);
s32 func_800BA2FC(GlobalContext* globalCtx, Actor* actor, Vec3f* param_3, f32 param_4);
void Actor_DrawAll(GlobalContext* globalCtx, ActorContext* aCtxt);
void func_800BA6FC(GlobalContext* globalCtx, ActorContext* aCtxt);
void func_800BA798(GlobalContext* globalCtx, ActorContext* aCtxt);
void func_800BA8B8(GlobalContext* globalCtx, ActorContext* actCtxt);
void Actor_DrawAll(GlobalContext* globalCtx, ActorContext* actorCtx);
void func_800BA6FC(GlobalContext* globalCtx, ActorContext* actorCtx);
void func_800BA798(GlobalContext* globalCtx, ActorContext* actorCtx);
void func_800BA8B8(GlobalContext* globalCtx, ActorContext* actorCtx);
// void func_800BA9B4(void);
void Actor_InsertIntoTypeList(ActorContext* actCtxt, Actor* actor, u8 type);
Actor* Actor_RemoveFromTypeList(GlobalContext* globalCtx, ActorContext* actCtxt, Actor* actor);
void Actor_InsertIntoTypeList(ActorContext* actorCtx, Actor* actor, u8 type);
Actor* Actor_RemoveFromTypeList(GlobalContext* globalCtx, ActorContext* actorCtx, Actor* actor);
void Actor_FreeOverlay(ActorOverlay* entry);
Actor* Actor_Spawn(ActorContext* actCtxt, GlobalContext* globalCtx, s16 index, f32 x, f32 y, f32 z, s16 rotX, s16 rotY, s16 rotZ, s16 sParm10);
ActorInit* Actor_LoadOverlay(ActorContext* actCtxt, s16 index);
Actor* Actor_SpawnWithParentAndCutscene(ActorContext* actCtxt, GlobalContext* globalCtx, s16 index, f32 x, f32 y, f32 z, s16 rotX, s16 rotY, s16 rotZ, s16 variable, u32 cutscene, s32 param_12, Actor* parent);
Actor* Actor_SpawnWithParent(ActorContext* actCtxt, Actor* parent, GlobalContext* globalCtx, s16 index, f32 x, f32 y, f32 z, s16 rotX, s16 rotY, s16 rotZ, s16 variable);
void Actor_SpawnTransitionActors(GlobalContext* globalCtx, ActorContext* actCtxt);
void func_800BB2D0(ActorContext* aCtxt, u16* param_2, GlobalContext* globalCtx);
Actor* func_800BB498(ActorContext* actCtxt, Actor* actor, GlobalContext* globalCtx);
Actor* Actor_Spawn(ActorContext* actorCtx, GlobalContext* globalCtx, s16 index, f32 x, f32 y, f32 z, s16 rotX, s16 rotY, s16 rotZ, s16 sParm10);
ActorInit* Actor_LoadOverlay(ActorContext* actorCtx, s16 index);
Actor* Actor_SpawnWithParentAndCutscene(ActorContext* actorCtx, GlobalContext* globalCtx, s16 index, f32 x, f32 y, f32 z, s16 rotX, s16 rotY, s16 rotZ, s16 variable, u32 cutscene, s32 param_12, Actor* parent);
Actor* Actor_SpawnWithParent(ActorContext* actorCtx, Actor* parent, GlobalContext* globalCtx, s16 index, f32 x, f32 y, f32 z, s16 rotX, s16 rotY, s16 rotZ, s16 variable);
void Actor_SpawnTransitionActors(GlobalContext* globalCtx, ActorContext* actorCtx);
void func_800BB2D0(ActorContext* actorCtx, u16* param_2, GlobalContext* globalCtx);
Actor* func_800BB498(ActorContext* actorCtx, Actor* actor, GlobalContext* globalCtx);
// void func_800BB59C(void);
// void func_800BB604(void);
// void func_800BB8EC(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5);
@ -881,7 +888,7 @@ void func_800BBA88(GlobalContext* globalCtx, Actor* actor);
void func_800BBB74(s16* arg1, UNK_TYPE1 arg2, UNK_TYPE1 arg3, UNK_TYPE4 arg4);
// void func_800BBC20(void);
// void func_800BBCEC(void);
// void func_800BBDAC(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE2 param_7, UNK_TYPE2 param_8, UNK_TYPE1 param_9);
// void func_800BBDAC(GlobalContext* globalCtx, UNK_PTR param_2, UNK_PTR param_3, f32 param_4, UNK_TYPE4 param_5, f32 param_6, s16 param_7, s16 param_8, u8 param_9);
void func_800BBFB0(GlobalContext* globalCtx, Vec3f* position, f32 param3, s32 param_4, s16 param_5, s16 param_6, u8 param_7);
void func_800BC154(GlobalContext* globalCtx, ActorContext* actorCtx, Actor* actor, u8 actorCategory);
// void func_800BC188(void);
@ -948,7 +955,7 @@ void BgCheck_PolygonGetNormal(CollisionPoly* polygon, f32* normalX, f32* normalY
void func_800C0094(struct CollisionPoly* param_1, f32 xOffset, f32 yOffset, f32 zOffset, MtxF* matrix);
f32 func_800C01B8(CollisionPoly* param_1, Vec3f* param_2);
void BgCheck_CreateColTriParamsFromPolygon(CollisionPoly* polygon, Vec3s* vertices, TriNorm* tri);
void func_800C02C0(CollisionPoly* poly, s32 index, CollisionContext* bgCtxt, TriNorm* tri);
void func_800C02C0(CollisionPoly* poly, s32 index, CollisionContext* colCtx, TriNorm* tri);
// void func_800C0340(CollisionPoly* param_1, Vec3s* param_2, UNK_TYPE4 param_3, UNK_TYPE4 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
// UNK_TYPE4 func_800C0474(CollisionPoly* param_1, Vec3s* param_2, UNK_TYPE4 param_3, UNK_TYPE4 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
// void func_800C0668(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5);
@ -956,8 +963,8 @@ void func_800C02C0(CollisionPoly* poly, s32 index, CollisionContext* bgCtxt, Tri
// void func_800C074C(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5);
// void func_800C07F0(void);
void BgCheck_PolygonCollidesWithSphere(CollisionPoly* polygon, Vec3s* verticies, Vec3f* pos, f32 readius);
void BgCheck_ScenePolygonListsInsertSorted(CollisionContext* bgCtxt, u16* head, CollisionPoly* polygons, Vec3s* vertices, s16 index);
void BgCheck_ScenePolygonListsInsert(StaticLookup* subdivision, CollisionContext* bgCtxt, CollisionPoly* polygons, Vec3s* vertices, s16 index);
void BgCheck_ScenePolygonListsInsertSorted(CollisionContext* colCtx, u16* head, CollisionPoly* polygons, Vec3s* vertices, s16 index);
void BgCheck_ScenePolygonListsInsert(StaticLookup* subdivision, CollisionContext* colCtx, CollisionPoly* polygons, Vec3s* vertices, s16 index);
// void func_800C0E74(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7, UNK_TYPE4 param_8, UNK_TYPE4 param_9, UNK_TYPE4 param_10);
// void func_800C10FC(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7, UNK_TYPE4 param_8, UNK_TYPE4 param_9);
// void func_800C1238(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE1 param_6, UNK_TYPE4 param_7, UNK_TYPE4 param_8, UNK_TYPE4 param_9, UNK_TYPE4 param_10, UNK_TYPE4 param_11);
@ -970,27 +977,27 @@ void BgCheck_ScenePolygonListsInsert(StaticLookup* subdivision, CollisionContext
// void func_800C2460(void);
// void func_800C2514(void);
// void func_800C25E0(void);
void BgCheck_GetPolyMinSubdivisions(CollisionContext* bgCtxt, Vec3f* min, s32* xSubdivision, s32* ySubdivision, s32* zSubdivision);
void BgCheck_GetPolyMaxSubdivisions(CollisionContext* bgCtxt, Vec3f* max, s32* xSubdivision, s32* ySubdivision, s32* zSubdivision);
void BgCheck_GetPolyMinMaxSubdivisions(CollisionContext* bgCtxt, Vec3s* vertices, CollisionPoly* polygons, s32* minX, s32* minY, s32* minZ, s32* maxX, s32* maxY, s32* maxZ, s16 index);
void BgCheck_GetPolyMinSubdivisions(CollisionContext* colCtx, Vec3f* min, s32* xSubdivision, s32* ySubdivision, s32* zSubdivision);
void BgCheck_GetPolyMaxSubdivisions(CollisionContext* colCtx, Vec3f* max, s32* xSubdivision, s32* ySubdivision, s32* zSubdivision);
void BgCheck_GetPolyMinMaxSubdivisions(CollisionContext* colCtx, Vec3s* vertices, CollisionPoly* polygons, s32* minX, s32* minY, s32* minZ, s32* maxX, s32* maxY, s32* maxZ, s16 index);
// UNK_TYPE4 func_800C2BE0(Vec3f* param_1, Vec3f* param_2, CollisionPoly* polygons, Vec3s* vertices, s16 index);
u32 BgCheck_SplitScenePolygonsIntoSubdivisions(CollisionContext* bgCtxt, GlobalContext* globalCtx, StaticLookup* subdivisions);
u32 BgCheck_SplitScenePolygonsIntoSubdivisions(CollisionContext* colCtx, GlobalContext* globalCtx, StaticLookup* subdivisions);
s32 BgCheck_GetIsDefaultSpecialScene(GlobalContext* globalCtx);
s32 BgCheck_GetSpecialSceneMaxMemory(s32 sceneId, u32* maxMemory);
void BgCheck_CalcSubdivisionSize(f32 min, s32 subdivisions, f32* max, f32* subdivisionSize, f32* inverseSubdivisionSize);
s32 BgCheck_GetSpecialSceneMaxObjects(GlobalContext* globalCtx, u32* maxNodes, u32* maxPolygons, u32* maxVertices);
void BgCheck_Init(CollisionContext* bgCtxt, GlobalContext* globalCtx, CollisionHeader* mesh);
void func_800C3C00(CollisionContext* bgCtxt, u32 param_2);
void func_800C3C14(CollisionContext* bgCtxt, u32 param_2);
CollisionHeader* BgCheck_GetActorMeshHeader(CollisionContext* bgCtxt, s32 index);
void BgCheck_Init(CollisionContext* colCtx, GlobalContext* globalCtx, CollisionHeader* mesh);
void func_800C3C00(CollisionContext* colCtx, u32 param_2);
void func_800C3C14(CollisionContext* colCtx, u32 param_2);
CollisionHeader* BgCheck_GetActorMeshHeader(CollisionContext* colCtx, s32 index);
// void func_800C3C94(void);
f32 func_800C3D50(s32 arg0, CollisionContext* bgCtxt, s32 arg2, CollisionPoly** arg3, s32* arg4, Vec3f* pos, Actor* actor, s32 arg7, f32 arg8, s32 arg9);
f32 func_800C3D50(s32 arg0, CollisionContext* colCtx, s32 arg2, CollisionPoly** arg3, s32* arg4, Vec3f* pos, Actor* actor, s32 arg7, f32 arg8, s32 arg9);
// void func_800C3F40(void);
// void func_800C3FA0(void);
// void func_800C4000(void);
// void func_800C4058(void);
// void func_800C40B4(void);
f32 func_800C411C(CollisionContext* bgCtxt, CollisionPoly** arg1, s32* arg2, Actor* actor, Vec3f* pos);
f32 func_800C411C(CollisionContext* colCtx, CollisionPoly** arg1, s32* arg2, Actor* actor, Vec3f* pos);
// void func_800C4188(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
// void func_800C41E4(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
// void func_800C4240(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
@ -1000,7 +1007,7 @@ f32 func_800C411C(CollisionContext* bgCtxt, CollisionPoly** arg1, s32* arg2, Act
// void func_800C4488(void);
// void func_800C44F0(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5);
// void func_800C455C(void);
s32 func_800C45C4(CollisionContext* bgCtxt, u32 param_2, Vec3f* param_3, Vec3f* param_4, Vec3f* param_5, f32 param_6, s32* param_7, s32* param_8, DynaPolyActor* param_9, f32 param_10, u8 param_11);
s32 func_800C45C4(CollisionContext* colCtx, u32 param_2, Vec3f* param_3, Vec3f* param_4, Vec3f* param_5, f32 param_6, s32* param_7, s32* param_8, DynaPolyActor* param_9, f32 param_10, u8 param_11);
// void func_800C4C74(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7);
// void func_800C4CD8(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7, UNK_TYPE4 param_8);
// void func_800C4D3C(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7, UNK_TYPE4 param_8, UNK_TYPE4 param_9);
@ -1047,7 +1054,7 @@ s32 BgCheck_IsActorMeshIndexValid(s32 index);
void BgCheck_DynaInit(GlobalContext* globalCtx, DynaCollisionContext* param_2);
void BgCheck_DynaAlloc(GlobalContext* globalCtx, DynaCollisionContext* dyna);
s32 BgCheck_AddActorMesh(GlobalContext* globalCtx, DynaCollisionContext* dyna, DynaPolyActor* actor, CollisionHeader* header);
DynaPolyActor* BgCheck_GetActorOfMesh(CollisionContext* bgCtxt, s32 index);
DynaPolyActor* BgCheck_GetActorOfMesh(CollisionContext* colCtx, s32 index);
void func_800C62BC(GlobalContext* globalCtx, DynaCollisionContext* dyna, s32 index);
void func_800C6314(GlobalContext* globalCtx, DynaCollisionContext* dyna, s32 index);
void func_800C636C(GlobalContext* globalCtx, DynaCollisionContext* dyna, s32 index);
@ -1076,45 +1083,45 @@ void BgCheck_UpdateAllActorMeshes(GlobalContext* globalCtx, DynaCollisionContext
// void func_800C9380(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7, UNK_TYPE2 param_8);
void BgCheck_RelocateMeshHeaderPointers(CollisionHeader* header);
void BgCheck_RelocateMeshHeader(CollisionHeader* meshSegPtr, CollisionHeader** param_2);
void BgCheck_RelocateAllMeshHeaders(CollisionContext* bgCtxt, GlobalContext* globalCtx);
void BgCheck_RelocateAllMeshHeaders(CollisionContext* colCtx, GlobalContext* globalCtx);
// void func_800C9640(void);
u32 BgCheck_GetPolygonAttributes(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index, s32 attributeIndex);
u32 func_800C9704(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
u32 BgCheck_GetPolygonAttributes(CollisionContext* colCtx, CollisionPoly* polygon, s32 index, s32 attributeIndex);
u32 func_800C9704(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
// void func_800C9728(void);
// UNK_TYPE4 func_800C9770(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
// UNK_TYPE4 func_800C9770(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
// void func_800C97F8(void);
// UNK_TYPE4 func_800C9844(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
// UNK_TYPE4 func_800C9844(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
// void func_800C98CC(void);
// UNK_TYPE4 func_800C9924(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
u32 func_800C99AC(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
u32 func_800C99D4(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
u32 func_800C99FC(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
u32 func_800C9A24(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
u32 func_800C9A4C(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
u32 func_800C9A7C(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
u32 func_800C9AB0(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
u32 func_800C9AE4(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
u32 func_800C9B18(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
u32 func_800C9B40(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
u32 func_800C9B68(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
u32 func_800C9B90(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
u32 func_800C9BB8(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
u32 func_800C9BDC(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
// u32 func_800C9C24(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index, UNK_TYPE4 param_4);
u32 func_800C9C74(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
u32 func_800C9C9C(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
u32 func_800C9CC4(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
u32 func_800C9CEC(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
// UNK_TYPE4 func_800C9924(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
u32 func_800C99AC(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
u32 func_800C99D4(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
u32 func_800C99FC(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
u32 func_800C9A24(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
u32 func_800C9A4C(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
u32 func_800C9A7C(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
u32 func_800C9AB0(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
u32 func_800C9AE4(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
u32 func_800C9B18(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
u32 func_800C9B40(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
u32 func_800C9B68(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
u32 func_800C9B90(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
u32 func_800C9BB8(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
u32 func_800C9BDC(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
// u32 func_800C9C24(CollisionContext* colCtx, CollisionPoly* polygon, s32 index, UNK_TYPE4 param_4);
u32 func_800C9C74(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
u32 func_800C9C9C(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
u32 func_800C9CC4(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
u32 func_800C9CEC(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
// void func_800C9D14(void);
// void func_800C9D50(void);
u32 func_800C9D8C(CollisionContext* param_1, CollisionPoly* param_2, s32 param_3);
// void func_800C9DDC(void);
u32 func_800C9E18(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
u32 func_800C9E40(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
u32 func_800C9E88(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
// void func_800C9EBC(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7);
// void func_800CA1AC(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
void func_800CA1E8(GlobalContext* globalCtx, CollisionContext* bgCtxt, f32 arg2, f32 arg3, f32* arg4, UNK_PTR arg5);
u32 func_800C9E18(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
u32 func_800C9E40(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
u32 func_800C9E88(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
// void func_800C9EBC(GlobalContext* globalCtx, CollisionContext* colCtx, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7);
// void func_800CA1AC(GlobalContext* globalCtx, CollisionContext* colCtx, f32 param_3, f32 param_4, f32* param_5, UNK_PTR param_6);
void func_800CA1E8(GlobalContext* globalCtx, CollisionContext* colCtx, f32 arg2, f32 arg3, f32* arg4, UNK_PTR arg5);
// void func_800CA22C(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
// void func_800CA568(void);
// void func_800CA634(void);
@ -1124,18 +1131,18 @@ void func_800CA1E8(GlobalContext* globalCtx, CollisionContext* bgCtxt, f32 arg2,
// void func_800CA6F0(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7);
// void func_800CA9D0(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
// void func_800CAA14(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5);
void BgCheck2_UpdateActorPosition(CollisionContext* bgCtxt, s32 index, Actor* actor);
void BgCheck2_UpdateActorYRotation(CollisionContext* bgCtxt, s32 index, Actor* actor);
void BgCheck2_AttachToMesh(CollisionContext* bgCtxt, Actor* actor, s32 index);
u32 BgCheck2_UpdateActorAttachedToMesh(CollisionContext* bgCtxt, s32 index, Actor* actor);
void BgCheck2_UpdateActorPosition(CollisionContext* colCtx, s32 index, Actor* actor);
void BgCheck2_UpdateActorYRotation(CollisionContext* colCtx, s32 index, Actor* actor);
void BgCheck2_AttachToMesh(CollisionContext* colCtx, Actor* actor, s32 index);
u32 BgCheck2_UpdateActorAttachedToMesh(CollisionContext* colCtx, s32 index, Actor* actor);
void BcCheck3_BgActorInit(DynaPolyActor* actor, UNK_TYPE4 param_2);
void BgCheck3_LoadMesh(GlobalContext* globalCtx, DynaPolyActor* actor, CollisionHeader* meshHeader);
void BgCheck3_ResetFlags(DynaPolyActor* actor);
void func_800CAE88(DynaPolyActor* actor);
void func_800CAE9C(DynaPolyActor* actor);
void func_800CAEB0(CollisionContext* bgCtxt, s32 index);
void func_800CAEB0(CollisionContext* colCtx, s32 index);
void func_800CAEE0(DynaPolyActor* actor);
void func_800CAEF4(CollisionContext* bgCtxt, s32 index);
void func_800CAEF4(CollisionContext* colCtx, s32 index);
void func_800CAF24(DynaPolyActor* actor);
void func_800CAF38(DynaPolyActor* actor);
s32 func_800CAF4C(DynaPolyActor* actor);
@ -1689,7 +1696,7 @@ s16 ActorCutscene_GetAdditionalCutscene(s16 index);
s16 ActorCutscene_GetLength(s16 index);
// void func_800F2138(void);
// void func_800F2178(void);
// s16 ActorCutscene_GetCurrentCamera(void);
s16 ActorCutscene_GetCurrentCamera(s16 index);
// void func_800F21CC(void);
// UNK_TYPE4 func_800F22C4(s16 param_1, Actor* actor);
void ActorCutscene_SetReturnCamera(s16 index);
@ -1740,7 +1747,7 @@ void Kanfont_LoadMessageBoxEnd(Font* font, u16 type);
void Kanfont_LoadOrderedFont(Font* font);
// void func_800F5090(void);
// void func_800F50D4(void);
void Kankyo_Init(GlobalContext* globalCtx, KankyoContext* kanCtxt);
void Kankyo_Init(GlobalContext* globalCtx, KankyoContext* envCtx);
u32 func_800F5954(u8* param_1, u32 param_2, u32 param_3, u8 param_4, u8 param_5);
// void func_800F5A8C(void);
// void func_800F5B10(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE2 param_5);
@ -1750,16 +1757,16 @@ u32 func_800F5954(u8* param_1, u32 param_2, u32 param_3, u8 param_4, u8 param_5)
// void func_800F6A04(void);
// void func_800F6A40(void);
// void func_800F6AB8(void);
void func_800F6B44(GlobalContext* globalCtx, KankyoContext* kanCtxt, s32 iParm3, s32 iParm4, s16* param_5);
void func_800F6B44(GlobalContext* globalCtx, KankyoContext* envCtx, s32 iParm3, s32 iParm4, s16* param_5);
// void func_800F6CEC(void);
// void func_800F6EA4(void);
// UNK_TYPE4 Kankyo_IsSceneUpsideDown(GlobalContext* globalCtx);
void func_800F6FF8(GlobalContext* globalCtx, KankyoContext* kanCtxt, LightContext* lCtxt);
void func_800F6FF8(GlobalContext* globalCtx, KankyoContext* envCtx, LightContext* lightCtx);
// void func_800F8554(void);
// void func_800F88C4(void);
// void func_800F8970(void);
// void func_800F8A9C(void);
// void func_800F8CD4(GlobalContext* globalCtx, KankyoContext* kanCtxt, LightContext* lCtxt, s32 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
// void func_800F8CD4(GlobalContext* globalCtx, KankyoContext* envCtx, LightContext* lightCtx, s32 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
// void func_800F8D84(void);
// void func_800F9728(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7);
// void func_800F9824(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7, UNK_TYPE4 param_8, UNK_TYPE4 param_9, UNK_TYPE2 param_10, UNK_TYPE1 param_11);
@ -2205,7 +2212,7 @@ s32 func_801224E0(s32 param_1, s16 param_2, s16 param_3);
// void func_80122660(void);
// UNK_TYPE4 func_80122670(s32* param_1, Input* input);
// void func_801226E0(void);
// void func_80122744(void);
void func_80122744(GlobalContext* globalCtx, UNK_PTR arg1, u32 arg2, Vec3s* arg3);
s32 func_80122760(GlobalContext* globalCtx, UNK_PTR arg1, f32 arg2);
void func_80122868(GlobalContext* globalCtx, ActorPlayer* player);
void func_801229A0(GlobalContext* globalCtx, ActorPlayer* player);
@ -2429,12 +2436,12 @@ void func_8012DEE8(GlobalContext* globalCtx, Room* room, u32 flags);
u32 func_8012E254(s32 param_1, GlobalContext* globalCtx);
void func_8012E32C(GlobalContext* globalCtx, Room* room, u32 flags);
void Room_DrawType1Mesh(GlobalContext* globalCtx, Room* room, u32 flags);
void Room_Init(GlobalContext* globalCtx, RoomContext* roomCtxt);
u32 Room_AllocateAndLoad(GlobalContext* globalCtx, RoomContext* roomCtxt);
s32 Room_StartRoomTransition(GlobalContext* globalCtx, RoomContext* roomCtxt, s32 index);
s32 Room_HandleLoadCallbacks(GlobalContext* globalCtx, RoomContext* roomCtxt);
void Room_Init(GlobalContext* globalCtx, RoomContext* roomCtx);
u32 Room_AllocateAndLoad(GlobalContext* globalCtx, RoomContext* roomCtx);
s32 Room_StartRoomTransition(GlobalContext* globalCtx, RoomContext* roomCtx, s32 index);
s32 Room_HandleLoadCallbacks(GlobalContext* globalCtx, RoomContext* roomCtx);
void Room_Draw(GlobalContext* globalCtx, Room* room, u32 flags);
void func_8012EBF8(GlobalContext* globalCtx, RoomContext* roomCtxt);
void func_8012EBF8(GlobalContext* globalCtx, RoomContext* roomCtx);
s32 func_8012EC80(GlobalContext* globalCtx);
void func_8012ED34(s16 equipment);
u8 func_8012ED78(GlobalContext* globalCtx, s16 equipment);
@ -2446,7 +2453,7 @@ void func_8012F1BC(s16 sceneIndex);
s16 func_8012F22C(s16 sceneIndex);
void func_8012F278(GlobalContext* globalCtx);
s32 Object_Spawn(ObjectContext* objectCtx, s16 id);
void Object_InitBank(GameState* state, ObjectContext* objectCtx);
void Object_InitBank(GameState* gamestate, ObjectContext* objectCtx);
void Object_UpdateBank(ObjectContext* objectCtx);
s32 Object_GetIndex(ObjectContext* objectCtx, s16 id);
s32 Object_IsLoaded(ObjectContext* objectCtx, s32 index);
@ -2465,7 +2472,7 @@ void Scene_HeaderCmdObjectList(GlobalContext* globalCtx, SceneCmd* cmd);
void Scene_HeaderCmdLightList(GlobalContext* globalCtx, SceneCmd* cmd);
void Scene_HeaderCmdPathList(GlobalContext* globalCtx, SceneCmd* cmd);
void Scene_HeaderCmdTransiActorList(GlobalContext* globalCtx, SceneCmd* cmd);
void Transition_Init(GameState* state, TransitionContext* transitionCtx);
void Transition_Init(GameState* gamestate, TransitionContext* transitionCtx);
void Scene_HeaderCmdEnvLightSettings(GlobalContext* globalCtx, SceneCmd* cmd);
s32 Scene_LoadAreaTextures(GlobalContext* globalCtx, s32 fileIndex);
void Scene_HeaderCmdSkyboxSettings(GlobalContext* globalCtx, SceneCmd* cmd);
@ -2809,9 +2816,9 @@ void func_801420F4(void* arg0);
void func_80142100(void* arg0, Gfx** gfx, u32 arg2);
s32 func_80142440(SkyboxContext* skyboxCtx, Vtx* vtx, s32 arg2, s32 arg3, s32 arg4, s32 arg5, s32 arg6, s32 arg7, s32 arg8); // func_80142440
void func_80143148(SkyboxContext* skyboxCtx, s32 arg1); // func_80143148
void func_801431E8(GameState* state, SkyboxContext* skyboxCtx, s16 skyType); // func_801431E8
void func_801431E8(GameState* gamestate, SkyboxContext* skyboxCtx, s16 skyType); // func_801431E8
void func_80143324(GlobalContext* globalCtx, SkyboxContext* skyboxCtx, s16 skyType); // func_80143324
void func_801434E4(GameState* state, SkyboxContext* skyboxCtx, s16 skyType); // func_801434E4
void func_801434E4(GameState* gamestate, SkyboxContext* skyboxCtx, s16 skyType); // func_801434E4
// void func_801435A0(void);
// void func_80143624(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE1 param_5, UNK_TYPE1 param_6, UNK_TYPE1 param_7);
// void func_80143668(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7);
@ -2830,13 +2837,13 @@ u32 Sram_CalcChecksum(u8* data, u32 length);
// void func_80144E78(void);
// void func_8014546C(void);
// void func_80145698(void);
void func_801457CC(GameState* ctxt, SramContext* param_2);
void func_801457CC(GameState* gamestate, SramContext* param_2);
void func_80146580(s32 param_1, SramContext* param_2, s32 param_3);
// void func_80146628(void);
// void func_80146AA0(void);
// void func_80146DF8(void);
// void func_80146E40(void);
void Sram_Alloc(GameState* ctxt, SramContext* iParm2);
void Sram_Alloc(GameState* gamestate, SramContext* iParm2);
// void func_80146EBC(SramContext* param_1, UNK_TYPE4 param_2, UNK_TYPE4 param_3);
// void func_80146EE8(void);
// void func_80146F5C(void);
@ -3052,10 +3059,10 @@ void func_801699D4(GlobalContext* globalCtx, s16 param_2, s16 param_3);
// void func_80169C84(void);
// void convert_scene_number_among_shared_scenes(void);
void func_80169D40(GlobalContext* globalCtx);
// void func_80169DCC(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE2 param_7);
void func_80169DCC(GlobalContext* globalCtx, s32 arg1, u16 arg2, s32 arg3, s32 arg4, Vec3f *arg5, s16 arg6);
void func_80169E6C(GlobalContext* globalCtx, s32 param_1, s32 param_2);
// void func_80169ECC(void);
// void func_80169EFC(void);
void func_80169EFC(GlobalContext* globalCtx);
// void func_80169F78(void);
// void func_80169FDC(void);
// void func_80169FFC(void);
@ -3149,22 +3156,22 @@ void TitleSetup_Init(GameState* gameState);
void Game_UpdateFramerateVariables(s32 divisor);
void Game_SetFramerateDivisor(GameState* gameState, s32 divisor);
void GameState_SetFBFilter(Gfx** gfx, u32 arg1);
void Game_Nop80173534(GameState* ctxt);
void GameState_Draw(GameState* ctxt, GraphicsContext* gfxCtx);
void Game_Nop80173534(GameState* gamestate);
void GameState_Draw(GameState* gamestate, GraphicsContext* gfxCtx);
void Game_ResetSegments(GraphicsContext* gfxCtx);
void func_801736DC(GraphicsContext* gfxCtx);
void Game_UpdateInput(GameState* ctxt);
void Game_Update(GameState* ctxt);
void Game_IncrementFrameCount(GameState* ctxt);
void Game_InitHeap(GameState* ctxt, u32 size);
void Game_ResizeHeap(GameState* ctxt, u32 size);
void Game_StateInit(GameState* ctxt, GameStateFunc gameStateInit, GraphicsContext* gfxCtx);
void Game_StateFini(GameState* ctxt);
GameStateFunc Game_GetNextStateInit(GameState* ctxt);
u32 Game_GetNextStateSize(GameState* ctxt);
u32 Game_GetShouldContinue(GameState* ctxt);
s32 Game_GetHeapFreeSize(GameState* ctxt);
s32 func_80173B48(GameState* ctxt);
void Game_UpdateInput(GameState* gamestate);
void Game_Update(GameState* gamestate);
void Game_IncrementFrameCount(GameState* gamestate);
void Game_InitHeap(GameState* gamestate, u32 size);
void Game_ResizeHeap(GameState* gamestate, u32 size);
void Game_StateInit(GameState* gamestate, GameStateFunc gameStateInit, GraphicsContext* gfxCtx);
void Game_StateFini(GameState* gamestate);
GameStateFunc Game_GetNextStateInit(GameState* gamestate);
u32 Game_GetNextStateSize(GameState* gamestate);
u32 Game_GetShouldContinue(GameState* gamestate);
s32 Game_GetHeapFreeSize(GameState* gamestate);
s32 func_80173B48(GameState* gamestate);
GameAlloc* func_80173BF0(GameAlloc* heap);
void* Gamealloc_Alloc(GameAlloc* heap, u32 size);
void Gamealloc_Free(GameAlloc* heap, void* ptr);
@ -3173,14 +3180,14 @@ void Gamealloc_Init(GameAlloc* iParm1);
// void Graph_FaultClient(void);
void Graph_DlAlloc(TwoHeadGfxArena* dl, void* memoryBlock, u32 size);
void Graph_InitTHGA(GraphicsContext* gfxCtx);
GameStateOverlay* Graph_GetNextGameState(GameState* ctxt);
GameStateOverlay* Graph_GetNextGameState(GameState* gamestate);
void* Graph_FaultAddrConvFunc(void* addr);
void Graph_Init(GraphicsContext* gfxCtx);
// void Graph_Destroy(void);
void Graph_Render(GraphicsContext* gfxCtx, GameState* ctxt);
void Graph_FrameSetup(GameState* ctxt);
void Graph_RenderFrame(GraphicsContext* gfxCtx, GameState* ctxt);
void Graph_DoFrame(GraphicsContext* gfxCtx, GameState* ctxt);
void Graph_Render(GraphicsContext* gfxCtx, GameState* gamestate);
void Graph_FrameSetup(GameState* gamestate);
void Graph_RenderFrame(GraphicsContext* gfxCtx, GameState* gamestate);
void Graph_DoFrame(GraphicsContext* gfxCtx, GameState* gamestate);
void Graph_ThreadEntry(void* arg);
Gfx* Graph_GfxPlusOne(Gfx* gfx);
Gfx* Graph_BranchDlist(Gfx* gfx, Gfx* dst);
@ -3381,12 +3388,12 @@ s16 Math_Atan2S(f32 opposite, f32 adjacent);
f32 Math_Atan2F(f32 opposite, f32 adjacent);
s16 Math_FAtan2F(f32 adjacent, f32 opposite);
f32 Math_Acot2F(f32 adjacent, f32 opposite);
void SysMatrix_StateAlloc(GameState* ctxt);
void SysMatrix_StateAlloc(GameState* gamestate);
void SysMatrix_StatePush(void);
void SysMatrix_StatePop(void);
void SysMatrix_CopyCurrentState(MtxF* matrix);
void SysMatrix_SetCurrentState(MtxF* matrix);
// MtxF* SysMatrix_GetCurrentState(void);
MtxF* SysMatrix_GetCurrentState(void);
void SysMatrix_InsertMatrix(MtxF* matrix, s32 appendToState);
void SysMatrix_InsertTranslation(f32 x, f32 y, f32 z, s32 appendToState);
void Matrix_Scale(f32 xScale, f32 yScale, f32 zScale, u8 appendToState);
@ -3405,7 +3412,7 @@ RSPMatrix* SysMatrix_ToRSPMatrix(MtxF* src, RSPMatrix* dst);
RSPMatrix* SysMatrix_GetStateAsRSPMatrix(RSPMatrix* matrix);
Mtx* Matrix_NewMtx(GraphicsContext* gfxCtx);
RSPMatrix* SysMatrix_AppendStateToPolyOpaDisp(GraphicsContext* gfxCtx);
void SysMatrix_AppendToPolyOpaDisp(MtxF* ctxt, GraphicsContext* gfxCtx);
void SysMatrix_AppendToPolyOpaDisp(MtxF* mtx, GraphicsContext* gfxCtx);
void SysMatrix_MultiplyVector3fByState(Vec3f* src, Vec3f* dst);
void SysMatrix_GetStateTranslation(Vec3f* dst);
void SysMatrix_GetStateTranslationAndScaledX(f32 scale, Vec3f* dst);
@ -3904,8 +3911,8 @@ void func_8019FAD8(Vec3f* param_1, u16 param_2, f32 param_3);
// void func_801A1D44(void);
// void func_801A1DB8(void);
// void func_801A1E0C(void);
// void func_801A1F00(void);
// void func_801A1F88(void);
void func_801A1F00(s32 arg0, s32 arg1);
void func_801A1F88(void);
// void func_801A1FB4(void);
// void func_801A2090(void);
void func_801A246C(u8 param_1, u8 param_2);
@ -4020,7 +4027,7 @@ void func_801A7794(u32 param_1, u32 param_2, u32 param_3);
// void func_801A7B10(void);
// void func_801A7D04(void);
// void func_801A7D84(void);
// void func_801A89A8(void);
// void func_801A89A8(UNK_TYPE arg0);
// void func_801A89D0(void);
s32 func_801A8A50(s32 param1);
// void func_801A8ABC(void);
@ -4050,6 +4057,6 @@ void nop_801AAAA0(GlobalContext* globalCtx);
// overlays
void Title_Init(TitleContext* ctxt);
void Title_Init(TitleContext* titleCtx);
#endif

40
src/code/code_0x800CAAD0.c
View File

@ -5,7 +5,7 @@
// Perhaps it is called something like z_bgcheck_attach.c
// The functions will use the BgCheck2 prefix for now.
void BgCheck2_UpdateActorPosition(CollisionContext* bgCtxt, s32 index, Actor* actor) {
void BgCheck2_UpdateActorPosition(CollisionContext* colCtx, s32 index, Actor* actor) {
MtxF prevMatrix;
MtxF prevMatrixInv;
MtxF currMatrix;
@ -17,22 +17,22 @@ void BgCheck2_UpdateActorPosition(CollisionContext* bgCtxt, s32 index, Actor* ac
}
SkinMatrix_SetScaleRotateYRPTranslate(
&prevMatrix, bgCtxt->dyna.bgActors[index].prevTransform.scale.x,
bgCtxt->dyna.bgActors[index].prevTransform.scale.y, bgCtxt->dyna.bgActors[index].prevTransform.scale.z,
bgCtxt->dyna.bgActors[index].prevTransform.rot.x, bgCtxt->dyna.bgActors[index].prevTransform.rot.y,
bgCtxt->dyna.bgActors[index].prevTransform.rot.z, bgCtxt->dyna.bgActors[index].prevTransform.pos.x,
bgCtxt->dyna.bgActors[index].prevTransform.pos.y, bgCtxt->dyna.bgActors[index].prevTransform.pos.z);
&prevMatrix, colCtx->dyna.bgActors[index].prevTransform.scale.x,
colCtx->dyna.bgActors[index].prevTransform.scale.y, colCtx->dyna.bgActors[index].prevTransform.scale.z,
colCtx->dyna.bgActors[index].prevTransform.rot.x, colCtx->dyna.bgActors[index].prevTransform.rot.y,
colCtx->dyna.bgActors[index].prevTransform.rot.z, colCtx->dyna.bgActors[index].prevTransform.pos.x,
colCtx->dyna.bgActors[index].prevTransform.pos.y, colCtx->dyna.bgActors[index].prevTransform.pos.z);
if (SkinMatrix_Invert(&prevMatrix, &prevMatrixInv) == 2) {
return;
}
SkinMatrix_SetScaleRotateYRPTranslate(
&currMatrix, bgCtxt->dyna.bgActors[index].curTransform.scale.x,
bgCtxt->dyna.bgActors[index].curTransform.scale.y, bgCtxt->dyna.bgActors[index].curTransform.scale.z,
bgCtxt->dyna.bgActors[index].curTransform.rot.x, bgCtxt->dyna.bgActors[index].curTransform.rot.y,
bgCtxt->dyna.bgActors[index].curTransform.rot.z, bgCtxt->dyna.bgActors[index].curTransform.pos.x,
bgCtxt->dyna.bgActors[index].curTransform.pos.y, bgCtxt->dyna.bgActors[index].curTransform.pos.z);
&currMatrix, colCtx->dyna.bgActors[index].curTransform.scale.x,
colCtx->dyna.bgActors[index].curTransform.scale.y, colCtx->dyna.bgActors[index].curTransform.scale.z,
colCtx->dyna.bgActors[index].curTransform.rot.x, colCtx->dyna.bgActors[index].curTransform.rot.y,
colCtx->dyna.bgActors[index].curTransform.rot.z, colCtx->dyna.bgActors[index].curTransform.pos.x,
colCtx->dyna.bgActors[index].curTransform.pos.y, colCtx->dyna.bgActors[index].curTransform.pos.z);
SkinMatrix_Vec3fMtxFMultXYZ(&prevMatrixInv, &actor->world.pos, &posWithInv);
SkinMatrix_Vec3fMtxFMultXYZ(&currMatrix, &posWithInv, &newPos);
@ -40,14 +40,14 @@ void BgCheck2_UpdateActorPosition(CollisionContext* bgCtxt, s32 index, Actor* ac
actor->world.pos = newPos;
}
void BgCheck2_UpdateActorYRotation(CollisionContext* bgCtxt, s32 index, Actor* actor) {
void BgCheck2_UpdateActorYRotation(CollisionContext* colCtx, s32 index, Actor* actor) {
s16 angleChange;
if (BgCheck_IsActorMeshIndexValid(index) == 0) {
return;
}
angleChange = bgCtxt->dyna.bgActors[index].curTransform.rot.y - bgCtxt->dyna.bgActors[index].prevTransform.rot.y;
angleChange = colCtx->dyna.bgActors[index].curTransform.rot.y - colCtx->dyna.bgActors[index].prevTransform.rot.y;
if (actor->id == 0) {
((ActorPlayer*)actor)->unkAD4 += angleChange;
@ -57,14 +57,14 @@ void BgCheck2_UpdateActorYRotation(CollisionContext* bgCtxt, s32 index, Actor* a
actor->world.rot.y += angleChange;
}
void BgCheck2_AttachToMesh(CollisionContext* bgCtxt, Actor* actor, s32 index) {
void BgCheck2_AttachToMesh(CollisionContext* colCtx, Actor* actor, s32 index) {
DynaPolyActor* meshActor;
if (BgCheck_IsActorMeshIndexValid(index) == 0) {
return;
}
meshActor = BgCheck_GetActorOfMesh(bgCtxt, index);
meshActor = BgCheck_GetActorOfMesh(colCtx, index);
if (meshActor != NULL) {
func_800CAE88(meshActor);
@ -77,7 +77,7 @@ void BgCheck2_AttachToMesh(CollisionContext* bgCtxt, Actor* actor, s32 index) {
}
}
u32 BgCheck2_UpdateActorAttachedToMesh(CollisionContext* bgCtxt, s32 index, Actor* actor) {
u32 BgCheck2_UpdateActorAttachedToMesh(CollisionContext* colCtx, s32 index, Actor* actor) {
u32 wasUpdated = 0;
DynaPolyActor* meshActor;
@ -85,23 +85,23 @@ u32 BgCheck2_UpdateActorAttachedToMesh(CollisionContext* bgCtxt, s32 index, Acto
return 0;
}
if (((bgCtxt->dyna.bgActorFlags[index] & 2) != 0) || ((bgCtxt->dyna.bgActorFlags[index] & 1) == 0)) {
if (((colCtx->dyna.bgActorFlags[index] & 2) != 0) || ((colCtx->dyna.bgActorFlags[index] & 1) == 0)) {
return 0;
}
meshActor = BgCheck_GetActorOfMesh(bgCtxt, index);
meshActor = BgCheck_GetActorOfMesh(colCtx, index);
if (meshActor == NULL) {
return 0;
}
if ((meshActor->unk154 & 1) != 0) {
BgCheck2_UpdateActorPosition(bgCtxt, index, actor);
BgCheck2_UpdateActorPosition(colCtx, index, actor);
wasUpdated = 1;
}
if ((meshActor->unk154 & 2) != 0) {
BgCheck2_UpdateActorYRotation(bgCtxt, index, actor);
BgCheck2_UpdateActorYRotation(colCtx, index, actor);
wasUpdated = 1;
}

8
src/code/code_0x800CAE10.c
View File

@ -29,10 +29,10 @@ void func_800CAE9C(DynaPolyActor* actor) {
actor->unk_158 |= 2;
}
void func_800CAEB0(CollisionContext* bgCtxt, s32 index) {
void func_800CAEB0(CollisionContext* colCtx, s32 index) {
DynaPolyActor* actor;
actor = BgCheck_GetActorOfMesh(bgCtxt, index);
actor = BgCheck_GetActorOfMesh(colCtx, index);
if (actor != (DynaPolyActor*)0x0) {
func_800CAE9C(actor);
}
@ -42,10 +42,10 @@ void func_800CAEE0(DynaPolyActor* actor) {
actor->unk_158 |= 4;
}
void func_800CAEF4(CollisionContext* bgCtxt, s32 index) {
void func_800CAEF4(CollisionContext* colCtx, s32 index) {
DynaPolyActor* actor;
actor = BgCheck_GetActorOfMesh(bgCtxt, index);
actor = BgCheck_GetActorOfMesh(colCtx, index);
if (actor != (DynaPolyActor*)0x0) {
func_800CAEE0(actor);
}

104
src/code/game.c
View File

@ -63,11 +63,11 @@ void GameState_SetFBFilter(Gfx** gfx, u32 arg1) {
*gfx = _gfx;
}
void Game_Nop80173534(GameState* ctxt) {
void Game_Nop80173534(GameState* gamestate) {
;
}
void GameState_Draw(GameState* ctxt, GraphicsContext* gfxCtx) {
void GameState_Draw(GameState* gamestate, GraphicsContext* gfxCtx) {
Gfx* nextDisplayList;
Gfx* _polyOpa;
// Unused vars impact regalloc
@ -95,7 +95,7 @@ lblUnk:; // Label prevents reordering, if(1) around the above block don't seem t
if (R_ENABLE_ARENA_DBG != 0) {
SpeedMeter_DrawTimeEntries(&D_801F7FF0, gfxCtx);
SpeedMeter_DrawAllocEntries(&D_801F7FF0, gfxCtx, ctxt);
SpeedMeter_DrawAllocEntries(&D_801F7FF0, gfxCtx, gamestate);
}
}
@ -120,46 +120,46 @@ void func_801736DC(GraphicsContext* gfxCtx) {
gfxCtx->polyOpa.p = nextDisplayList;
}
void Game_UpdateInput(GameState* ctxt) {
Padmgr_GetInput(ctxt->input, 1);
void Game_UpdateInput(GameState* gamestate) {
Padmgr_GetInput(gamestate->input, 1);
}
void Game_Update(GameState* ctxt) {
void Game_Update(GameState* gamestate) {
GraphicsContext* _gCtx;
_gCtx = ctxt->gfxCtx;
_gCtx = gamestate->gfxCtx;
Game_ResetSegments(ctxt->gfxCtx);
Game_ResetSegments(gamestate->gfxCtx);
ctxt->main(ctxt);
gamestate->main(gamestate);
if (R_PAUSE_MENU_MODE != 2) {
GameState_Draw(ctxt, _gCtx);
GameState_Draw(gamestate, _gCtx);
func_801736DC(_gCtx);
}
}
void Game_IncrementFrameCount(GameState* ctxt) {
Game_Nop80173534(ctxt);
ctxt->frames++;
void Game_IncrementFrameCount(GameState* gamestate) {
Game_Nop80173534(gamestate);
gamestate->frames++;
}
void Game_InitHeap(GameState* ctxt, u32 size) {
void Game_InitHeap(GameState* gamestate, u32 size) {
GameState* _ctx;
void* buf;
_ctx = ctxt;
_ctx = gamestate;
buf = Gamealloc_Alloc(&_ctx->alloc, size);
if (buf) {
THA_Ct(&ctxt->heap, buf, size);
THA_Ct(&gamestate->heap, buf, size);
return;
}
THA_Ct(&ctxt->heap, NULL, 0);
THA_Ct(&gamestate->heap, NULL, 0);
assert_fail("../game.c", 0x40B);
}
void Game_ResizeHeap(GameState* ctxt, u32 size) {
void Game_ResizeHeap(GameState* gamestate, u32 size) {
GameAlloc* alloc;
void* buf;
u32 systemMaxFree;
@ -167,9 +167,9 @@ void Game_ResizeHeap(GameState* ctxt, u32 size) {
u32 bytesAllocated;
void* heapStart;
heapStart = ctxt->heap.bufp;
alloc = &ctxt->alloc;
THA_Dt(&ctxt->heap);
heapStart = gamestate->heap.bufp;
alloc = &gamestate->alloc;
THA_Dt(&gamestate->heap);
Gamealloc_Free(alloc, heapStart);
StartHeap_AnalyzeArena(&systemMaxFree, &bytesFree, &bytesAllocated);
size = ((systemMaxFree - (sizeof(ArenaNode))) < size) ? (0) : (size);
@ -178,32 +178,32 @@ void Game_ResizeHeap(GameState* ctxt, u32 size) {
}
if (buf = Gamealloc_Alloc(alloc, size)) {
THA_Ct(&ctxt->heap, buf, size);
THA_Ct(&gamestate->heap, buf, size);
} else {
THA_Ct(&ctxt->heap, 0, 0);
THA_Ct(&gamestate->heap, 0, 0);
assert_fail("../game.c", 0x432);
}
}
void Game_StateInit(GameState* ctxt, GameStateFunc gameStateInit, GraphicsContext* gfxCtx) {
ctxt->gfxCtx = gfxCtx;
ctxt->frames = 0U;
ctxt->main = NULL;
ctxt->destroy = NULL;
ctxt->running = 1;
void Game_StateInit(GameState* gamestate, GameStateFunc gameStateInit, GraphicsContext* gfxCtx) {
gamestate->gfxCtx = gfxCtx;
gamestate->frames = 0U;
gamestate->main = NULL;
gamestate->destroy = NULL;
gamestate->running = 1;
gfxCtx->unk274 = D_801FBB88;
gfxCtx->viConfigFeatures = gViConfigFeatures;
gfxCtx->viConfigXScale = gViConfigXScale;
gfxCtx->viConfigYScale = gViConfigYScale;
ctxt->nextGameStateInit = NULL;
ctxt->nextGameStateSize = 0U;
gamestate->nextGameStateInit = NULL;
gamestate->nextGameStateSize = 0U;
lblUnk:;
Gamealloc_Init(&ctxt->alloc);
Game_InitHeap(ctxt, 0x100000);
Game_SetFramerateDivisor(ctxt, 3);
Gamealloc_Init(&gamestate->alloc);
Game_InitHeap(gamestate, 0x100000);
Game_SetFramerateDivisor(gamestate, 3);
gameStateInit(ctxt);
gameStateInit(gamestate);
func_80140CE0(&D_801F8010);
func_801420C0(&D_801F8020);
@ -212,16 +212,16 @@ lblUnk:;
func_801773A0(&D_801F7FF0);
func_8013ED9C();
osSendMesg(&ctxt->gfxCtx->unk5C, NULL, 1);
osSendMesg(&gamestate->gfxCtx->unk5C, NULL, 1);
}
void Game_StateFini(GameState* ctxt) {
void Game_StateFini(GameState* gamestate) {
func_80172BC0();
func_8019E014();
osRecvMesg(&ctxt->gfxCtx->unk5C, 0, 1);
osRecvMesg(&gamestate->gfxCtx->unk5C, 0, 1);
if (ctxt->destroy != 0) {
ctxt->destroy(ctxt);
if (gamestate->destroy != 0) {
gamestate->destroy(gamestate);
}
func_8013EDD0();
@ -230,28 +230,28 @@ void Game_StateFini(GameState* ctxt) {
func_801420F4(&D_801F8020);
func_80141900(&sMonoColors);
func_80140900(&D_801F8048);
THA_Dt(&ctxt->heap);
Gamealloc_FreeAll(&ctxt->alloc);
THA_Dt(&gamestate->heap);
Gamealloc_FreeAll(&gamestate->alloc);
}
GameStateFunc Game_GetNextStateInit(GameState* ctxt) {
return ctxt->nextGameStateInit;
GameStateFunc Game_GetNextStateInit(GameState* gamestate) {
return gamestate->nextGameStateInit;
}
u32 Game_GetNextStateSize(GameState* ctxt) {
return ctxt->nextGameStateSize;
u32 Game_GetNextStateSize(GameState* gamestate) {
return gamestate->nextGameStateSize;
}
u32 Game_GetShouldContinue(GameState* ctxt) {
return ctxt->running;
u32 Game_GetShouldContinue(GameState* gamestate) {
return gamestate->running;
}
s32 Game_GetHeapFreeSize(GameState* ctxt) {
return THA_GetSize(&ctxt->heap);
s32 Game_GetHeapFreeSize(GameState* gamestate) {
return THA_GetSize(&gamestate->heap);
}
s32 func_80173B48(GameState* ctxt) {
s32 func_80173B48(GameState* gamestate) {
s32 result;
result = OS_CYCLES_TO_NSEC(ctxt->framerateDivisor * sIrqMgrRetraceTime) - OS_CYCLES_TO_NSEC(D_801FBAF0);
result = OS_CYCLES_TO_NSEC(gamestate->framerateDivisor * sIrqMgrRetraceTime) - OS_CYCLES_TO_NSEC(D_801FBAF0);
return result;
}

10
src/code/sys_matrix.c
View File

@ -1,25 +1,25 @@
#include <ultra64.h>
#include <global.h>
void Matrix_Init(GameState* state) {
sMatrixStack = (MtxF*)THA_AllocEndAlign16(&state->heap, 0x500);
void SysMatrix_StateAlloc(GameState* gamestate) {
sMatrixStack = (MtxF*)THA_AllocEndAlign16(&gamestate->heap, 0x500);
sCurrentMatrix = sMatrixStack;
}
void Matrix_Push(void) {
void SysMatrix_StatePush(void) {
MtxF* prev = sCurrentMatrix;
sCurrentMatrix++;
Matrix_MtxFCopy(sCurrentMatrix, prev);
}
void Matrix_Pop(void) {
void SysMatrix_StatePop(void) {
sCurrentMatrix--;
}
#pragma GLOBAL_ASM("./asm/non_matchings/code/sys_matrix/SysMatrix_CopyCurrentState.asm")
#pragma GLOBAL_ASM("./asm/non_matchings/code/sys_matrix/Matrix_Put.asm")
#pragma GLOBAL_ASM("./asm/non_matchings/code/sys_matrix/SysMatrix_SetCurrentState.asm")
#pragma GLOBAL_ASM("./asm/non_matchings/code/sys_matrix/SysMatrix_GetCurrentState.asm")

64
src/code/z_actor.c
View File

@ -54,7 +54,7 @@ void ActorShadow_Draw(Actor* actor, Lights* lights, GlobalContext* globalCtx, Gf
}
func_800C0094(actor->floorPoly, actor->world.pos.x, actor->floorHeight, actor->world.pos.z, &mtx);
Matrix_Put(&mtx);
SysMatrix_SetCurrentState(&mtx);
if (dlist != D_04076BC0) {
Matrix_RotateY((f32)actor->shape.rot.y * (M_PI / 32768), MTXMODE_APPLY);
@ -118,7 +118,7 @@ void func_800B40E0(GlobalContext* globalCtx, Light* light, MtxF* arg2, s32 arg3,
sp58 = Math_FAtan2F(light->l.dir[0], light->l.dir[2]);
arg6 *= (4.5f - (light->l.dir[1] * D_801DCA1C));
arg6 = (arg6 < 1.0f) ? 1.0f : arg6;
Matrix_Put(arg2);
SysMatrix_SetCurrentState(arg2);
Matrix_RotateY(sp58, MTXMODE_APPLY);
Matrix_Scale(arg5, 1.0f, arg5 * arg6, MTXMODE_APPLY);
@ -147,16 +147,16 @@ void func_800B40E0(GlobalContext* globalCtx, Light* light, MtxF* arg2, s32 arg3,
#pragma GLOBAL_ASM("./asm/non_matchings/code/z_actor//func_800B5040.asm")
void Actor_TargetContextInit(TargetContext* targetCtxt, Actor* actor, GlobalContext* globalCtx) {
targetCtxt->unk90 = NULL;
targetCtxt->unk8C = NULL;
targetCtxt->unk3C = NULL;
targetCtxt->unk38 = NULL;
targetCtxt->unk4B = 0;
targetCtxt->unk4C = 0;
targetCtxt->unk40 = 0;
func_800B5040(targetCtxt, actor, actor->category, globalCtx);
func_800B4F78(targetCtxt, actor->category, globalCtx);
void Actor_TargetContextInit(TargetContext* targetCtx, Actor* actor, GlobalContext* globalCtx) {
targetCtx->unk90 = NULL;
targetCtx->unk8C = NULL;
targetCtx->unk3C = NULL;
targetCtx->unk38 = NULL;
targetCtx->unk4B = 0;
targetCtx->unk4C = 0;
targetCtx->unk40 = 0;
func_800B5040(targetCtx, actor, actor->category, globalCtx);
func_800B4F78(targetCtx, actor->category, globalCtx);
}
#pragma GLOBAL_ASM("./asm/non_matchings/code/z_actor//func_800B5208.asm")
@ -235,34 +235,34 @@ void Actor_SetCollectibleFlag(GlobalContext* globalCtx, s32 index) {
}
}
void Actor_TitleCardContextInit(GlobalContext* globalCtx, TitleCardContext* titleCtxt) {
titleCtxt->fadeOutDelay = 0;
titleCtxt->fadeInDelay = 0;
titleCtxt->color = 0;
titleCtxt->alpha = 0;
void Actor_TitleCardContextInit(GlobalContext* globalCtx, TitleCardContext* titleCardCtx) {
titleCardCtx->fadeOutDelay = 0;
titleCardCtx->fadeInDelay = 0;
titleCardCtx->color = 0;
titleCardCtx->alpha = 0;
}
void Actor_TitleCardCreate(GlobalContext* globalCtx, TitleCardContext* titleCtxt, u32 texture, s16 param_4, s16 param_5,
void Actor_TitleCardCreate(GlobalContext* globalCtx, TitleCardContext* titleCardCtx, u32 texture, s16 param_4, s16 param_5,
u8 param_6, u8 param_7) {
titleCtxt->texture = texture;
titleCtxt->unk4 = param_4;
titleCtxt->unk6 = param_5;
titleCtxt->unk8 = param_6;
titleCtxt->unk9 = param_7;
titleCtxt->fadeOutDelay = 80;
titleCtxt->fadeInDelay = 0;
titleCardCtx->texture = texture;
titleCardCtx->unk4 = param_4;
titleCardCtx->unk6 = param_5;
titleCardCtx->unk8 = param_6;
titleCardCtx->unk9 = param_7;
titleCardCtx->fadeOutDelay = 80;
titleCardCtx->fadeInDelay = 0;
}
#pragma GLOBAL_ASM("./asm/non_matchings/code/z_actor//Actor_Nop800B5E50.asm")
void Actor_TitleCardUpdate(GlobalContext* globalCtx, TitleCardContext* titleCtxt) {
if (DECR(titleCtxt->fadeInDelay) == 0) {
if (DECR(titleCtxt->fadeOutDelay) == 0) {
Math_StepToS(&titleCtxt->alpha, 0, 30);
Math_StepToS(&titleCtxt->color, 0, 70);
void Actor_TitleCardUpdate(GlobalContext* globalCtx, TitleCardContext* titleCardCtx) {
if (DECR(titleCardCtx->fadeInDelay) == 0) {
if (DECR(titleCardCtx->fadeOutDelay) == 0) {
Math_StepToS(&titleCardCtx->alpha, 0, 30);
Math_StepToS(&titleCardCtx->color, 0, 70);
} else {
Math_StepToS(&titleCtxt->alpha, 255, 10);
Math_StepToS(&titleCtxt->color, 255, 20);
Math_StepToS(&titleCardCtx->alpha, 255, 10);
Math_StepToS(&titleCardCtx->color, 255, 20);
}
}
}

4
src/code/z_bgcheck.c
View File

@ -162,8 +162,8 @@ void BgCheck_CreateVertexFromVec3f(Vec3s* vertex, Vec3f* vector) {
#pragma GLOBAL_ASM("./asm/non_matchings/code/z_bgcheck/func_800C40B4.asm")
f32 func_800C411C(CollisionContext* bgCtxt, CollisionPoly** arg1, s32* arg2, Actor* actor, Vec3f* pos) {
return func_800C3D50(0, bgCtxt, 2, arg1, arg2, pos, actor, 28, 1.0f, 0);
f32 func_800C411C(CollisionContext* colCtx, CollisionPoly** arg1, s32* arg2, Actor* actor, Vec3f* pos) {
return func_800C3D50(0, colCtx, 2, arg1, arg2, pos, actor, 28, 1.0f, 0);
}
#pragma GLOBAL_ASM("./asm/non_matchings/code/z_bgcheck/func_800C4188.asm")

2
src/code/z_eff_footmark.c
View File

@ -107,7 +107,7 @@ void EffFootmark_Draw(GlobalContext* globalCtx) {
for (footmark = globalCtx->footmarks, i = 0; i < 100; i++, footmark++) {
if (footmark->actor != NULL) {
Matrix_Put(&footmark->displayMatrix);
SysMatrix_SetCurrentState(&footmark->displayMatrix);
Matrix_Scale(footmark->size * 0.00390625f * 0.7f, 1, footmark->size * 0.00390625f, 1);
gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD);

8
src/code/z_effect.c
View File

@ -187,7 +187,7 @@ void Effect_Add(GlobalContext* globalCtx, s32* index, s32 type, u8 param_4, u8 p
void Effect_DrawAll(GraphicsContext* gfxCtx) {
s32 i;
for (i = 0; i < SPARK_COUNT; i++) {
for (i = 0; i < SPARK_COUNT; i++) {
if (1) {} // necessary to match
if (sEffTable.sparks[i].base.active) {
sEffInfoTable[0].draw(&sEffTable.sparks[i].params, gfxCtx);
@ -195,8 +195,10 @@ void Effect_DrawAll(GraphicsContext* gfxCtx) {
}
for (i = 0; i < BLURE_COUNT; i++) {
if (1) { if (gfxCtx) {} } // necessary to match
if (sEffTable.blures[i].base.active) {
if (1) {
if (gfxCtx) {}
} // necessary to match
if (sEffTable.blures[i].base.active) {
sEffInfoTable[1].draw(&sEffTable.blures[i].params, gfxCtx);
}
}

22
src/code/z_effect_soft_sprite.c
View File

@ -10,7 +10,8 @@ void EffectSS_Init(GlobalContext* globalCtx, s32 numEntries) {
EffectSS2Info.searchIndex = 0;
EffectSS2Info.size = numEntries;
for (effectsSs = &EffectSS2Info.data_table[0]; effectsSs < &EffectSS2Info.data_table[EffectSS2Info.size]; effectsSs++) {
for (effectsSs = &EffectSS2Info.data_table[0]; effectsSs < &EffectSS2Info.data_table[EffectSS2Info.size];
effectsSs++) {
EffectSS_ResetEntry(effectsSs);
}
@ -97,7 +98,7 @@ s32 EffectSS_FindFreeSpace(s32 priority, s32* tableEntry) {
// Search for a unused entry
i = EffectSS2Info.searchIndex;
foundFree = false;
while(true) {
while (true) {
if (EffectSS2Info.data_table[i].life == -1) {
foundFree = true;
break;
@ -118,12 +119,12 @@ s32 EffectSS_FindFreeSpace(s32 priority, s32* tableEntry) {
if (foundFree == true) {
*tableEntry = i;
return false;
}
}
// If all slots are in use, search for a slot with a lower priority
// Note that a lower priority is representend by a higher value
i = EffectSS2Info.searchIndex;
while(true) {
while (true) {
// Equal priority should only be considered "lower" if flag 0 is set
if ((priority <= EffectSS2Info.data_table[i].priority) &&
!((priority == EffectSS2Info.data_table[i].priority) && (EffectSS2Info.data_table[i].flags & 1))) {
@ -181,14 +182,13 @@ void EffectSs_Spawn(GlobalContext* globalCtx, s32 type, s32 priority, void* init
return;
}
Load2_LoadOverlay(entry->vromStart, entry->vromEnd, entry->vramStart, entry->vramEnd,
entry->loadedRamAddr);
Load2_LoadOverlay(entry->vromStart, entry->vromEnd, entry->vramStart, entry->vramEnd, entry->loadedRamAddr);
}
overlayInfo = (void*)(u32)(entry->overlayInfo != NULL
? (ParticleOverlayInfo*)(-((u32)entry->vramStart - (u32)entry->loadedRamAddr) +
(u32)entry->overlayInfo)
: NULL);
overlayInfo = (void*)(u32)(
entry->overlayInfo != NULL
? (ParticleOverlayInfo*)(-((u32)entry->vramStart - (u32)entry->loadedRamAddr) + (u32)entry->overlayInfo)
: NULL);
}
if (overlayInfo->init != NULL) {

62
src/code/z_room.c
View File

@ -63,39 +63,39 @@ void Room_DrawType1Mesh(GlobalContext* globalCtx, Room* room, u32 flags) {
}
}
void Room_Init(GlobalContext* globalCtx, RoomContext* roomCtxt) {
void Room_Init(GlobalContext* globalCtx, RoomContext* roomCtx) {
s32 i;
roomCtxt->currRoom.num = -1;
roomCtxt->currRoom.segment = NULL;
roomCtxt->unk78 = 1;
roomCtxt->unk79 = 0;
roomCtx->currRoom.num = -1;
roomCtx->currRoom.segment = NULL;
roomCtx->unk78 = 1;
roomCtx->unk79 = 0;
for (i = 0; i < 3; i++) {
roomCtxt->unk7A[i] = 0;
roomCtx->unk7A[i] = 0;
}
}
#pragma GLOBAL_ASM("./asm/non_matchings/code/z_room/Room_AllocateAndLoad.asm")
#ifdef NON_MATCHING
s32 Room_StartRoomTransition(GlobalContext* globalCtx, RoomContext* roomCtxt, s32 index) {
s32 Room_StartRoomTransition(GlobalContext* globalCtx, RoomContext* roomCtx, s32 index) {
u32 size;
// XXX: this should use a branch-likely
if (roomCtxt->unk31 == 0) {
roomCtxt->prevRoom = roomCtxt->currRoom;
roomCtxt->currRoom.num = index;
roomCtxt->currRoom.segment = NULL;
roomCtxt->unk31 = 1;
if (roomCtx->unk31 == 0) {
roomCtx->prevRoom = roomCtx->currRoom;
roomCtx->currRoom.num = index;
roomCtx->currRoom.segment = NULL;
roomCtx->unk31 = 1;
size = globalCtx->roomAddrs[index].vromEnd - globalCtx->roomAddrs[index].vromStart;
roomCtxt->activeRoomVram =
(void*)((s32)roomCtxt->roomMemPages[roomCtxt->activeMemPage] - (size + 8) * roomCtxt->activeMemPage + 8) &
roomCtx->activeRoomVram =
(void*)((s32)roomCtx->roomMemPages[roomCtx->activeMemPage] - (size + 8) * roomCtx->activeMemPage + 8) &
0xfffffff0;
osCreateMesgQueue(&roomCtxt->loadQueue, roomCtxt->loadMsg, 1);
DmaMgr_SendRequestImpl(&roomCtxt->dmaRequest, roomCtxt->activeRoomVram, globalCtx->roomAddrs[index].vromStart,
size, 0, &roomCtxt->loadQueue, NULL);
roomCtxt->activeMemPage ^= 1;
osCreateMesgQueue(&roomCtx->loadQueue, roomCtx->loadMsg, 1);
DmaMgr_SendRequestImpl(&roomCtx->dmaRequest, roomCtx->activeRoomVram, globalCtx->roomAddrs[index].vromStart,
size, 0, &roomCtx->loadQueue, NULL);
roomCtx->activeMemPage ^= 1;
return 1;
}
@ -106,19 +106,19 @@ s32 Room_StartRoomTransition(GlobalContext* globalCtx, RoomContext* roomCtxt, s3
#pragma GLOBAL_ASM("./asm/non_matchings/code/z_room/Room_StartRoomTransition.asm")
#endif
s32 Room_HandleLoadCallbacks(GlobalContext* globalCtx, RoomContext* roomCtxt) {
if (roomCtxt->unk31 == 1) {
if (!osRecvMesg(&roomCtxt->loadQueue, NULL, OS_MESG_NOBLOCK)) {
roomCtxt->unk31 = 0;
roomCtxt->currRoom.segment = roomCtxt->activeRoomVram;
s32 Room_HandleLoadCallbacks(GlobalContext* globalCtx, RoomContext* roomCtx) {
if (roomCtx->unk31 == 1) {
if (!osRecvMesg(&roomCtx->loadQueue, NULL, OS_MESG_NOBLOCK)) {
roomCtx->unk31 = 0;
roomCtx->currRoom.segment = roomCtx->activeRoomVram;
// TODO: Segment number enum
gSegments[3] = PHYSICAL_TO_VIRTUAL(roomCtxt->activeRoomVram);
gSegments[3] = PHYSICAL_TO_VIRTUAL(roomCtx->activeRoomVram);
Scene_ProcessHeader(globalCtx, (SceneCmd*)roomCtxt->currRoom.segment);
Scene_ProcessHeader(globalCtx, (SceneCmd*)roomCtx->currRoom.segment);
func_80123140(globalCtx, PLAYER);
Actor_SpawnTransitionActors(globalCtx, &globalCtx->actorCtx);
if (((globalCtx->sceneNum != SCENE_IKANA) || (roomCtxt->currRoom.num != 1)) &&
if (((globalCtx->sceneNum != SCENE_IKANA) || (roomCtx->currRoom.num != 1)) &&
(globalCtx->sceneNum != SCENE_IKNINSIDE)) {
globalCtx->kankyoContext.unkC3 = 0xff;
globalCtx->kankyoContext.unkE0 = 0;
@ -144,13 +144,13 @@ void Room_Draw(GlobalContext* globalCtx, Room* room, u32 flags) {
return;
}
void func_8012EBF8(GlobalContext* globalCtx, RoomContext* roomCtxt) {
roomCtxt->prevRoom.num = -1;
roomCtxt->prevRoom.segment = NULL;
void func_8012EBF8(GlobalContext* globalCtx, RoomContext* roomCtx) {
roomCtx->prevRoom.num = -1;
roomCtx->prevRoom.segment = NULL;
func_800BA798(globalCtx, &globalCtx->actorCtx);
Actor_SpawnTransitionActors(globalCtx, &globalCtx->actorCtx);
if (-1 < roomCtxt->currRoom.num) {
func_8010A33C(globalCtx, roomCtxt->currRoom.num);
if (-1 < roomCtx->currRoom.num) {
func_8010A33C(globalCtx, roomCtx->currRoom.num);
func_8010A2DC(globalCtx);
}
func_801A3CD8(globalCtx->roomContext.currRoom.echo);

8
src/code/z_scene.c
View File

@ -24,8 +24,8 @@ s32 Object_Spawn(ObjectContext* objectCtx, s16 id) {
return objectCtx->num - 1;
}
void Object_InitBank(GameState* state, ObjectContext* objectCtx) {
GlobalContext* globalCtx = (GlobalContext*)state;
void Object_InitBank(GameState* gamestate, ObjectContext* objectCtx) {
GlobalContext* globalCtx = (GlobalContext*)gamestate;
s32 pad;
u32 spaceSize;
s32 i;
@ -50,7 +50,7 @@ void Object_InitBank(GameState* state, ObjectContext* objectCtx) {
for (i = 0; i < OBJECT_EXCHANGE_BANK_MAX; i++) { objectCtx->status[i].id = 0; }
// clang-format on
objectCtx->spaceStart = objectCtx->status[0].segment = THA_AllocEndAlign16(&state->heap, spaceSize);
objectCtx->spaceStart = objectCtx->status[0].segment = THA_AllocEndAlign16(&gamestate->heap, spaceSize);
objectCtx->spaceEnd = (void*)((u32)objectCtx->spaceStart + spaceSize);
objectCtx->mainKeepIndex = Object_Spawn(objectCtx, GAMEPLAY_KEEP);
@ -328,7 +328,7 @@ void Scene_HeaderCmdTransiActorList(GlobalContext* globalCtx, SceneCmd* cmd) {
}
// Init function for the transition system.
void Transition_Init(GameState* state, TransitionContext* transitionCtx) {
void Transition_Init(GameState* gamestate, TransitionContext* transitionCtx) {
transitionCtx->nbTransitionActors = 0;
}

64
src/code/z_skelanime.c
View File

@ -40,7 +40,7 @@ void SkelAnime_LodDrawLimb(GlobalContext* globalCtx, s32 limbIndex, void** skele
GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
s32 pad;
Matrix_Push();
SysMatrix_StatePush();
limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
limbIndex++;
rot = limbDrawTable[limbIndex];
@ -71,7 +71,7 @@ void SkelAnime_LodDrawLimb(GlobalContext* globalCtx, s32 limbIndex, void** skele
postLimbDraw, actor, dListIndex);
}
Matrix_Pop();
SysMatrix_StatePop();
if (limbEntry->nextLimbIndex != LIMB_DONE) {
SkelAnime_LodDrawLimb(globalCtx, limbEntry->nextLimbIndex, skeleton, limbDrawTable, overrideLimbDraw,
@ -98,7 +98,7 @@ void SkelAnime_LodDraw(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDra
gfxCtx = globalCtx->state.gfxCtx;
Matrix_Push();
SysMatrix_StatePush();
limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[0]);
pos.x = limbDrawTable[0].x;
@ -130,7 +130,7 @@ void SkelAnime_LodDraw(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDra
postLimbDraw, actor, dListIndex);
}
Matrix_Pop();
SysMatrix_StatePop();
}
/*
@ -147,7 +147,7 @@ void SkelAnime_LodDrawLimbSV(GlobalContext* globalCtx, s32 limbIndex, void** ske
GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
s32 pad;
Matrix_Push();
SysMatrix_StatePush();
limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
limbIndex++;
@ -183,7 +183,7 @@ void SkelAnime_LodDrawLimbSV(GlobalContext* globalCtx, s32 limbIndex, void** ske
postLimbDraw, actor, dListIndex, mtx);
}
Matrix_Pop();
SysMatrix_StatePop();
if (limbEntry->nextLimbIndex != LIMB_DONE) {
SkelAnime_LodDrawLimbSV(globalCtx, limbEntry->nextLimbIndex, skeleton, limbDrawTable, overrideLimbDraw,
@ -217,7 +217,7 @@ void SkelAnime_LodDrawSV(GlobalContext* globalCtx, void** skeleton, Vec3s* limbD
gfxCtx = globalCtx->state.gfxCtx;
gSPSegment(gfxCtx->polyOpa.p++, 0xD, mtx);
Matrix_Push();
SysMatrix_StatePush();
limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[0]);
pos.x = limbDrawTable[0].x;
@ -253,7 +253,7 @@ void SkelAnime_LodDrawSV(GlobalContext* globalCtx, void** skeleton, Vec3s* limbD
postLimbDraw, actor, dListIndex, &mtx);
}
Matrix_Pop();
SysMatrix_StatePop();
}
/*
@ -268,7 +268,7 @@ void SkelAnime_DrawLimb(GlobalContext* globalCtx, s32 limbIndex, void** skeleton
GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
s32 pad;
Matrix_Push();
SysMatrix_StatePush();
limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
limbIndex++;
@ -298,7 +298,7 @@ void SkelAnime_DrawLimb(GlobalContext* globalCtx, s32 limbIndex, void** skeleton
postLimbDraw, actor);
}
Matrix_Pop();
SysMatrix_StatePop();
if (limbEntry->nextLimbIndex != LIMB_DONE) {
SkelAnime_DrawLimb(globalCtx, limbEntry->nextLimbIndex, skeleton, limbDrawTable, overrideLimbDraw, postLimbDraw,
@ -322,7 +322,7 @@ void SkelAnime_Draw(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTa
gfxCtx = globalCtx->state.gfxCtx;
Matrix_Push();
SysMatrix_StatePush();
rootLimb = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[0]);
pos.x = limbDrawTable[0].x;
@ -352,7 +352,7 @@ void SkelAnime_Draw(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTa
postLimbDraw, actor);
}
Matrix_Pop();
SysMatrix_StatePop();
}
void SkelAnime_DrawLimbSV(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* limbDrawTable,
@ -365,7 +365,7 @@ void SkelAnime_DrawLimbSV(GlobalContext* globalCtx, s32 limbIndex, void** skelet
GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
s32 pad;
Matrix_Push();
SysMatrix_StatePush();
limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
limbIndex++;
@ -400,7 +400,7 @@ void SkelAnime_DrawLimbSV(GlobalContext* globalCtx, s32 limbIndex, void** skelet
postLimbDraw, actor, limbMatricies);
}
Matrix_Pop();
SysMatrix_StatePop();
if (limbEntry->nextLimbIndex != LIMB_DONE) {
SkelAnime_DrawLimbSV(globalCtx, limbEntry->nextLimbIndex, skeleton, limbDrawTable, overrideLimbDraw,
@ -429,7 +429,7 @@ void SkelAnime_DrawSV(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDraw
gSPSegment(gfxCtx->polyOpa.p++, 0xD, mtx);
Matrix_Push();
SysMatrix_StatePush();
limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[0]);
@ -467,7 +467,7 @@ void SkelAnime_DrawSV(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDraw
postLimbDraw, actor, &mtx);
}
Matrix_Pop();
SysMatrix_StatePop();
}
void func_80134148(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* limbDrawTable,
@ -480,7 +480,7 @@ void func_80134148(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec
GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
s32 pad2;
Matrix_Push();
SysMatrix_StatePush();
limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
limbIndex++;
@ -495,7 +495,7 @@ void func_80134148(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec
if ((overrideLimbDraw == NULL) || (overrideLimbDraw(globalCtx, limbIndex, &dList[1], &pos, &rot, actor) == 0)) {
SysMatrix_RotateAndTranslateState(&pos, &rot);
Matrix_Push();
SysMatrix_StatePush();
unkDraw(globalCtx, limbIndex, actor);
if (dList[1] != NULL) {
Gfx* polyTemp = gfxCtx->polyOpa.p;
@ -510,7 +510,7 @@ void func_80134148(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec
(*mtx)++;
}
}
Matrix_Pop();
SysMatrix_StatePop();
}
if (postLimbDraw != NULL) {
@ -522,7 +522,7 @@ void func_80134148(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec
unkDraw, actor, mtx);
}
Matrix_Pop();
SysMatrix_StatePop();
if (limbEntry->nextLimbIndex != LIMB_DONE) {
func_80134148(globalCtx, limbEntry->nextLimbIndex, skeleton, limbDrawTable, overrideLimbDraw, postLimbDraw,
@ -551,7 +551,7 @@ void func_801343C0(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTab
gSPSegment(gfxCtx->polyOpa.p++, 0xD, mtx);
Matrix_Push();
SysMatrix_StatePush();
limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[0]);
@ -565,7 +565,7 @@ void func_801343C0(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTab
if ((overrideLimbDraw == NULL) || (overrideLimbDraw(globalCtx, 1, &dList[1], &pos, &rot, actor) == 0)) {
SysMatrix_RotateAndTranslateState(&pos, &rot);
Matrix_Push();
SysMatrix_StatePush();
unkDraw(globalCtx, 1, actor);
if (dList[1] != NULL) {
Gfx* polyTemp = gfxCtx->polyOpa.p;
@ -579,7 +579,7 @@ void func_801343C0(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTab
SysMatrix_GetStateAsRSPMatrix(mtx++);
}
}
Matrix_Pop();
SysMatrix_StatePop();
}
if (postLimbDraw != NULL) {
@ -591,7 +591,7 @@ void func_801343C0(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTab
unkDraw, actor, &mtx);
}
Matrix_Pop();
SysMatrix_StatePop();
}
/*
@ -641,7 +641,7 @@ Gfx* SkelAnime_Draw2Limb(GlobalContext* globalCtx, s32 limbIndex, void** skeleto
Vec3f pos;
Vec3s rot;
Matrix_Push();
SysMatrix_StatePush();
limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
limbIndex++;
@ -671,7 +671,7 @@ Gfx* SkelAnime_Draw2Limb(GlobalContext* globalCtx, s32 limbIndex, void** skeleto
postLimbDraw, actor, gfx);
}
Matrix_Pop();
SysMatrix_StatePop();
if (limbEntry->nextLimbIndex != LIMB_DONE) {
gfx = SkelAnime_Draw2Limb(globalCtx, limbEntry->nextLimbIndex, skeleton, limbDrawTable, overrideLimbDraw,
@ -697,7 +697,7 @@ Gfx* SkelAnime_Draw2(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawT
return NULL;
}
Matrix_Push();
SysMatrix_StatePush();
limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[0]);
@ -726,7 +726,7 @@ Gfx* SkelAnime_Draw2(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawT
postLimbDraw, actor, gfx);
}
Matrix_Pop();
SysMatrix_StatePop();
return gfx;
}
@ -744,7 +744,7 @@ Gfx* SkelAnime_DrawLimbSV2(GlobalContext* globalCtx, s32 limbIndex, void** skele
Vec3f pos;
Vec3s rot;
Matrix_Push();
SysMatrix_StatePush();
limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
limbIndex++;
@ -780,7 +780,7 @@ Gfx* SkelAnime_DrawLimbSV2(GlobalContext* globalCtx, s32 limbIndex, void** skele
postLimbDraw, actor, mtx, gfx);
}
Matrix_Pop();
SysMatrix_StatePop();
if (limbEntry->nextLimbIndex != LIMB_DONE) {
gfx = SkelAnime_DrawLimbSV2(globalCtx, limbEntry->nextLimbIndex, skeleton, limbDrawTable, overrideLimbDraw,
@ -808,7 +808,7 @@ Gfx* SkelAnime_DrawSV2(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDra
gSPSegment(gfx++, 0xD, mtx);
Matrix_Push();
SysMatrix_StatePush();
limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[0]);
@ -844,7 +844,7 @@ Gfx* SkelAnime_DrawSV2(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDra
postLimbDraw, actor, &mtx, gfx);
}
Matrix_Pop();
SysMatrix_StatePop();
return gfx;
}

2
src/code/z_view.c
View File

@ -258,7 +258,7 @@ s32 View_StepQuake(View* view, RSPMatrix* matrix) {
}
SysMatrix_FromRSPMatrix(matrix, &mf);
Matrix_Put(&mf);
SysMatrix_SetCurrentState(&mf);
SysMatrix_RotateStateAroundXAxis(view->currQuakeRot.x);
SysMatrix_InsertYRotation_f(view->currQuakeRot.y, 1);
SysMatrix_InsertZRotation_f(view->currQuakeRot.z, 1);

12
src/code/z_vr_box.c
View File

@ -38,7 +38,7 @@ void func_80143148(SkyboxContext* skyboxCtx, s32 arg1) {
#ifdef NON_MATCHING
// Matches besides rodata, since rodata is not merged into the asm in code files yet.
void func_801431E8(GameState* state, SkyboxContext* skyboxCtx, s16 skyType) {
void func_801431E8(GameState* gamestate, SkyboxContext* skyboxCtx, s16 skyType) {
GlobalContext* globalCtx = (GlobalContext*)state;
u32 size;
void* offset;
@ -139,22 +139,22 @@ void func_80143324(GlobalContext* globalCtx, SkyboxContext* skyboxCtx, s16 skyTy
}
}
void func_801434E4(GameState* state, SkyboxContext* skyboxCtx, s16 skyType) {
void func_801434E4(GameState* gamestate, SkyboxContext* skyboxCtx, s16 skyType) {
skyboxCtx->skyboxShouldDraw = 0;
skyboxCtx->rotX = skyboxCtx->rotY = skyboxCtx->rotZ = 0.0f;
func_801431E8(state, skyboxCtx, skyType);
func_801431E8(gamestate, skyboxCtx, skyType);
if (skyType != 0) {
skyboxCtx->unk17C = THA_AllocEndAlign16(&state->heap, 0x3840);
skyboxCtx->unk17C = THA_AllocEndAlign16(&gamestate->heap, 0x3840);
if (skyType == 5) {
// Allocate enough space for the vertices for a 6 sided skybox (cube)
skyboxCtx->roomVtx = THA_AllocEndAlign16(&state->heap, sizeof(Vtx) * 32 * 6);
skyboxCtx->roomVtx = THA_AllocEndAlign16(&gamestate->heap, sizeof(Vtx) * 32 * 6);
func_80143148(skyboxCtx, 6);
} else {
// Allocate enough space for the vertices for a 5 sided skybox (bottom is missing)
skyboxCtx->roomVtx = THA_AllocEndAlign16(&state->heap, sizeof(Vtx) * 32 * 5);
skyboxCtx->roomVtx = THA_AllocEndAlign16(&gamestate->heap, sizeof(Vtx) * 32 * 5);
func_80143148(skyboxCtx, 5);
}
}

2
src/overlays/actors/ovl_Arms_Hook/z_arms_hook.c
View File

@ -135,7 +135,7 @@ void ArmsHook_Shoot(ArmsHook* this, GlobalContext* globalCtx) {
return;
}
func_800B8F98(&player->base, 0x100B);
func_800B8F98(&player->base, NA_SE_IT_HOOKSHOT_CHAIN - SFX_FLAG);
ArmsHook_CheckForCancel(this);
if (this->timer != 0 && (this->collider.base.atFlags & AT_HIT) &&

2
src/overlays/actors/ovl_Bg_Iknin_Susceil/z_bg_iknin_susceil.c
View File

@ -223,7 +223,7 @@ void BgIkninSusceil_Update(Actor* thisx, GlobalContext* globalCtx) {
if ((this->unk168 == 0) && (this->unk166 > 0) && ((player->unkA74 & 0x100) != 0) && (player->unkB48 > 1000.0f)) {
this->unk168 = 2;
if ((func_80C0A95C(this, globalCtx) != 0) && (this->actionFunc != func_80C0AE5C)) {
func_800B8E58(player, 0x83E);
func_800B8E58(&player->base, NA_SE_PL_BODY_HIT);
func_80C0AE3C(this);
}
}

8
src/overlays/actors/ovl_En_Fg/z_en_fg.c
View File

@ -360,11 +360,11 @@ void EnFg_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec
if ((limbIndex == 7) || (limbIndex == 8)) {
OPEN_DISPS(globalCtx->state.gfxCtx);
Matrix_Push();
SysMatrix_StatePush();
SysMatrix_NormalizeXYZ(&globalCtx->unk187FC);
gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
gSPDisplayList(POLY_OPA_DISP++, *dList);
Matrix_Pop();
SysMatrix_StatePop();
CLOSE_DISPS(globalCtx->state.gfxCtx);
}
@ -381,9 +381,9 @@ void EnFg_Draw(Actor* thisx, GlobalContext* globalCtx) {
{ 120, 130, 230, 255 }, { 190, 190, 190, 255 }, { 0, 0, 0, 255 },
};
Matrix_Push();
SysMatrix_StatePush();
EnFg_DrawDust(globalCtx, &this->dustEffect[0]);
Matrix_Pop();
SysMatrix_StatePop();
OPEN_DISPS(globalCtx->state.gfxCtx);
func_8012C28C(globalCtx->state.gfxCtx);

36
src/overlays/actors/ovl_En_Ginko_Man/z_en_ginko_man.c
View File

@ -143,7 +143,8 @@ void EnGinkoMan_DepositDialogue(EnGinkoMan* this, GlobalContext* globalCtx) {
this->curTextId = 0x44E; //" ...So, what'll it be? Deposit Rupees Don't deposit Rupees"
} else {
func_801518B0(globalCtx, 0x44D, &this->actor);
this->curTextId = 0x44D; // "For example, if you deposit 200 Rupees, you'll get an item that holds a lot of Rupees."
this->curTextId =
0x44D; // "For example, if you deposit 200 Rupees, you'll get an item that holds a lot of Rupees."
}
break;
case 0x44D: // "For example, if you deposit 200 Rupees, you'll get an item that holds a lot of Rupees."
@ -189,7 +190,7 @@ void EnGinkoMan_DepositDialogue(EnGinkoMan* this, GlobalContext* globalCtx) {
func_801518B0(globalCtx, 0x45B, &this->actor);
this->curTextId = 0x45B; // "What's this? You've already saved up 200 Rupees!?!
} else if (((gSaveContext.roomInf[127][0] & 0xFFFF) >= 1000) && ((this->previousBankValue) < 1000) &&
!(gSaveContext.weekEventReg[59] & 0x80)) {
!(gSaveContext.weekEventReg[59] & 0x80)) {
gSaveContext.weekEventReg[59] |= 0x80;
func_801518B0(globalCtx, 0x45C, &this->actor);
this->curTextId = 0x45C; // "What's this? You've already saved up 1000 Rupees!?!
@ -201,7 +202,8 @@ void EnGinkoMan_DepositDialogue(EnGinkoMan* this, GlobalContext* globalCtx) {
} else if (this->previousBankValue < (s16)(gSaveContext.roomInf[127][0] & 0xFFFF)) {
func_800BDC5C(&this->skelAnime, animations, GINKO_SITTING);
func_801518B0(globalCtx, 0x45E, &this->actor);
this->curTextId = 0x45E; // "...Hang on there, little guy. I can't take any more deposits. Sorry..."
this->curTextId =
0x45E; // "...Hang on there, little guy. I can't take any more deposits. Sorry..."
} else {
func_800BDC5C(&this->skelAnime, animations, GINKO_FLOORSMACKING);
func_801518B0(globalCtx, 0x460, &this->actor);
@ -248,7 +250,7 @@ void EnGinkoMan_DepositDialogue(EnGinkoMan* this, GlobalContext* globalCtx) {
func_801518B0(globalCtx, 0x468, &this->actor);
this->curTextId = 0x468; // " Deposit Rupees Withdraw Rupees Nothing really"
break;
case 0x469: // "Excuse me, but let me take a look at you..."
case 0x469: // "Excuse me, but let me take a look at you..."
EnGinkoMan_SetupStamp(this); // stamp player
break;
case 0x46A: // "Ah, yes...[Link]. If I remember, you're the little guy who deposited [rupees]."
@ -281,7 +283,8 @@ void EnGinkoMan_DepositDialogue(EnGinkoMan* this, GlobalContext* globalCtx) {
func_801518B0(globalCtx, 0x46E, &this->actor);
this->curTextId = 0x46E; // "How much do you want? [rupee prompt]
break;
case 0x46D: // "Look, little guy, if it's 'cause of the bad rumors going around, forget it! They're just rumors!"
case 0x46D: // "Look, little guy, if it's 'cause of the bad rumors going around, forget it! They're just
// rumors!"
func_801518B0(globalCtx, 0x46B, &this->actor);
this->curTextId = 0x46B; // So...
break;
@ -292,7 +295,8 @@ void EnGinkoMan_DepositDialogue(EnGinkoMan* this, GlobalContext* globalCtx) {
EnGinkoMan_SetupIdle(this); // change to waiting for approach
}
break;
case 0x476: // "...You haven't deposited that many Rupees, so that much isn't available for withdrawal. Do the math!
case 0x476: // "...You haven't deposited that many Rupees, so that much isn't available for withdrawal. Do the
// math!
func_800BDC5C(&this->skelAnime, animations, GINKO_SITTING);
case 0x475: // "What's this? Look, little guy, you can't hold this many rupees! You got that?"
case 0x47C: // "Is that so? Think it over, little guy! So what are you gonna do?"
@ -302,7 +306,8 @@ void EnGinkoMan_DepositDialogue(EnGinkoMan* this, GlobalContext* globalCtx) {
break;
case 0x472: // "What's this? It's a waste to take out such a tiny bit! ...But if you say so!"
case 0x473: // Use it wisely...
case 0x474: // "Aw, you're taking out all that? If you spend it like that, it'll all be gone before you know it!"
case 0x474: // "Aw, you're taking out all that? If you spend it like that, it'll all be gone before you know
// it!"
if ((gSaveContext.roomInf[127][0] & 0xFFFF) == 0) {
func_801518B0(globalCtx, 0x478, &this->actor);
// "Look, little guy, all the Rupees you deposited are gone, so you can't use that stamp anymore."
@ -375,16 +380,17 @@ void EnGinkoMan_WaitForDialogueInput(EnGinkoMan* this, GlobalContext* globalCtx)
func_801518B0(globalCtx, 0x453, &this->actor);
this->curTextId = 0x453; // That's it? That aint nothing at all
}
if ((gSaveContext.roomInf[127][0] & 0xFFFF) == 0) {
this->isNewAccount = true;
}
func_801159EC((s16) -globalCtx->msgCtx.bankRupeesSelected);
func_801159EC((s16)-globalCtx->msgCtx.bankRupeesSelected);
this->previousBankValue = gSaveContext.roomInf[127][0] & 0xFFFF;
if (1) {} // Needed to match
gSaveContext.roomInf[127][0] =
(gSaveContext.roomInf[127][0] & 0xFFFF0000) | ((gSaveContext.roomInf[127][0] & 0xFFFF) + globalCtx->msgCtx.bankRupeesSelected);
(gSaveContext.roomInf[127][0] & 0xFFFF0000) |
((gSaveContext.roomInf[127][0] & 0xFFFF) + globalCtx->msgCtx.bankRupeesSelected);
}
} else { // GINKOMAN_CHOICE_NO
func_8019F230();
@ -444,7 +450,9 @@ void EnGinkoMan_WaitForDialogueInput(EnGinkoMan* this, GlobalContext* globalCtx)
this->previousBankValue = (s16)(gSaveContext.roomInf[127][0] & 0xFFFF);
gSaveContext.roomInf[127][0] =
(gSaveContext.roomInf[127][0] & 0xFFFF0000) | (((gSaveContext.roomInf[127][0] & 0xFFFF) - globalCtx->msgCtx.bankRupeesSelected) - this->serviceFee);
(gSaveContext.roomInf[127][0] & 0xFFFF0000) |
(((gSaveContext.roomInf[127][0] & 0xFFFF) - globalCtx->msgCtx.bankRupeesSelected) -
this->serviceFee);
func_801159EC(globalCtx->msgCtx.bankRupeesSelected);
}
} else {
@ -554,7 +562,8 @@ void EnGinkoMan_SetupBankAward2(EnGinkoMan* this) {
void EnGinkoMan_BankAward2(EnGinkoMan* this, GlobalContext* globalCtx) {
if (func_800B84D0(&this->actor, globalCtx)) {
if (!(gSaveContext.weekEventReg[10] & 8) && (this->curTextId == 0x45B)) {
// "What's this? You've already saved up 200 Rupees!?! Well, little guy, here's your special gift. Take it!"
// "What's this? You've already saved up 200 Rupees!?! Well, little guy, here's your special gift. Take
// it!"
gSaveContext.weekEventReg[10] |= 8;
func_801518B0(globalCtx, 0x47A, &this->actor);
this->curTextId = 0x47A; // "See! Doesn't it hold more than your old one?
@ -646,7 +655,8 @@ void EnGinkoMan_Update(Actor* thisx, GlobalContext* globalCtx) {
EnGinkoMan_FacePlayer(this, globalCtx);
}
s32 EnGinkoMan_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, Actor* thisx) {
s32 EnGinkoMan_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot,
Actor* thisx) {
EnGinkoMan* this = THIS;
if (limbIndex == 15) {

43
src/overlays/actors/ovl_En_Minifrog/z_en_minifrog.c
View File

@ -75,7 +75,7 @@ static UNK_TYPE4* D_808A4D74[] = {
// gSaveContext.weekEventReg[KEY] = VALUE
// KEY | VALUE
static u16 isFrogReturnedFlags[] = {
(0 << 8) | 0x00, // NULL
(0 << 8) | 0x00, // NULL
(32 << 8) | 0x40, // Woodfall Temple Frog Returned
(32 << 8) | 0x80, // Great Bay Temple Frog Returned
(33 << 8) | 0x01, // Southern Swamp Frog Returned
@ -94,7 +94,8 @@ void EnMinifrog_Init(Actor* thisx, GlobalContext* globalCtx) {
Actor_ProcessInitChain(&this->actor, sInitChain);
ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 15.0f);
SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600B538, &D_06001534, this->limbDrawTable, this->transitionDrawTable, 24);
SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600B538, &D_06001534, this->limbDrawTable,
this->transitionDrawTable, 24);
CollisionCheck_SetInfo(&this->actor.colChkInfo, NULL, &sColChkInfoInit);
Collider_InitAndSetCylinder(globalCtx, &this->collider, &this->actor, &sCylinderInit);
@ -118,7 +119,9 @@ void EnMinifrog_Init(Actor* thisx, GlobalContext* globalCtx) {
if (1) {}
if (!EN_MINIFROG_IS_RETURNED(this)) {
if ((this->frogIndex == MINIFROG_YELLOW) || ((gSaveContext.weekEventReg[isFrogReturnedFlags[this->frogIndex] >> 8] & (u8)isFrogReturnedFlags[this->frogIndex]))) {
if ((this->frogIndex == MINIFROG_YELLOW) ||
((gSaveContext.weekEventReg[isFrogReturnedFlags[this->frogIndex] >> 8] &
(u8)isFrogReturnedFlags[this->frogIndex]))) {
Actor_MarkForDeath(&this->actor);
} else {
this->timer = 30;
@ -143,7 +146,8 @@ void EnMinifrog_Init(Actor* thisx, GlobalContext* globalCtx) {
this->actor.flags &= ~1;
// Frog has been returned
if ((gSaveContext.weekEventReg[isFrogReturnedFlags[this->frogIndex] >> 8] & (u8)isFrogReturnedFlags[this->frogIndex])) {
if ((gSaveContext.weekEventReg[isFrogReturnedFlags[this->frogIndex] >> 8] &
(u8)isFrogReturnedFlags[this->frogIndex])) {
this->actionFunc = EnMinifrog_SetupNextFrogInit;
} else {
this->actor.draw = NULL;
@ -272,7 +276,7 @@ void EnMinifrog_ReturnFrogCutscene(EnMinifrog* this, GlobalContext* globalCtx) {
case 0xD87: // "Ah! You need not say a thing. Upon seeing that face, I understand!" ...
func_80151938(globalCtx, globalCtx->msgCtx.unk11F04 + 1);
break;
case 0xD82: // "What has brought you all this way?"
case 0xD82: // "What has brought you all this way?"
if (gSaveContext.weekEventReg[33] & 0x80) { // Mountain village is unfrozen
func_80151938(globalCtx, 0xD83); // "Could it be... Has spring finally come to the mountains?"
} else {
@ -280,7 +284,8 @@ void EnMinifrog_ReturnFrogCutscene(EnMinifrog* this, GlobalContext* globalCtx) {
}
flag = gSaveContext.weekEventReg[isFrogReturnedFlags[this->frogIndex] >> 8];
gSaveContext.weekEventReg[isFrogReturnedFlags[this->frogIndex] >> 8] = flag | (u8)isFrogReturnedFlags[this->frogIndex];
gSaveContext.weekEventReg[isFrogReturnedFlags[this->frogIndex] >> 8] =
flag | (u8)isFrogReturnedFlags[this->frogIndex];
break;
case 0xD85: // "I understand. I shall head for the mountains immediately."
default:
@ -332,7 +337,8 @@ void EnMinifrog_Idle(EnMinifrog* this, GlobalContext* globalCtx) {
if (this->actor.cutscene != -1) {
this->flags |= 1;
}
} else if ((this->actor.xzDistToPlayer < 100.0f) && Actor_IsLinkFacingActor(&this->actor, 0x3000, globalCtx) && (func_8012403C(globalCtx) == 0xD)) {
} else if ((this->actor.xzDistToPlayer < 100.0f) && Actor_IsLinkFacingActor(&this->actor, 0x3000, globalCtx) &&
(func_8012403C(globalCtx) == 0xD)) {
func_800B8614(&this->actor, globalCtx, 110.0f);
}
}
@ -346,7 +352,8 @@ void EnMinifrog_SetupNextFrogInit(EnMinifrog* this, GlobalContext* globalCtx) {
if (nextFrog != NULL) {
missingFrog = nextFrog->frog;
if (nextFrog->frog != NULL) {
this->actor.home.rot.y = (s16)Actor_YawBetweenActors(&this->actor, &missingFrog->actor); // Set home to missing frog
this->actor.home.rot.y =
(s16)Actor_YawBetweenActors(&this->actor, &missingFrog->actor); // Set home to missing frog
EnMinifrog_TurnToMissingFrog(this);
} else {
EnMinifrog_TurnToPlayer(this);
@ -364,7 +371,8 @@ void EnMinifrog_CheckChoirSuccess(EnMinifrog* this, GlobalContext* globalCtx) {
if (this->frog != NULL) {
func_80151938(globalCtx, 0xD78); // "Unfortunately, it seems not all of our members have gathered."
} else {
func_80151938(globalCtx, 0xD7C); // "The conducting was spectacular. And all of our members rose to the occasion!"
func_80151938(globalCtx,
0xD7C); // "The conducting was spectacular. And all of our members rose to the occasion!"
}
EnMinifrog_SetJumpState(this);
@ -562,13 +570,17 @@ void EnMinifrog_SetupYellowFrogDialog(EnMinifrog* this, GlobalContext* globalCtx
EnMinifrog_JumpTimer(this);
if (func_800B84D0(&this->actor, globalCtx)) {
this->actionFunc = EnMinifrog_YellowFrogDialog;
if (!(gSaveContext.weekEventReg[34] & 1)) { // Not spoken with MINIFROG_YELLOW
func_801518B0(globalCtx, 0xD76, &this->actor); // "I have been waiting for you, Don Gero. Forgive me if I'm mistaken, but it
// looks like you've lost a little weight..."
if (!(gSaveContext.weekEventReg[34] & 1)) { // Not spoken with MINIFROG_YELLOW
func_801518B0(globalCtx, 0xD76,
&this->actor); // "I have been waiting for you, Don Gero. Forgive me if I'm mistaken, but it
// looks like you've lost a little weight..."
} else {
func_801518B0(globalCtx, 0xD7F, &this->actor); // "Well, if it isn't the great Don Gero."
}
} else if ((this->actor.xzDistToPlayer < 150.0f) && (Actor_IsLinkFacingActor(&this->actor, 0x3000, globalCtx) || ((this->actor.flags & 0x10000) == 0x10000)) && func_8012403C(globalCtx) == 0xD) {
} else if ((this->actor.xzDistToPlayer < 150.0f) &&
(Actor_IsLinkFacingActor(&this->actor, 0x3000, globalCtx) ||
((this->actor.flags & 0x10000) == 0x10000)) &&
func_8012403C(globalCtx) == 0xD) {
func_800B8614(&this->actor, globalCtx, 160.0f);
}
}
@ -595,7 +607,8 @@ void EnMinifrog_UpdateMissingFrog(Actor* thisx, GlobalContext* globalCtx) {
}
}
s32 EnMinifrog_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, Actor* thisx) {
s32 EnMinifrog_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot,
Actor* thisx) {
if (limbIndex == 1) {
pos->z -= 500.0f;
}
@ -617,7 +630,7 @@ void EnMinifrog_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dLis
gSPDisplayList(POLY_OPA_DISP++, *dList);
CLOSE_DISPS(globalCtx->state.gfxCtx);
}
if (limbIndex == 4) {
SysMatrix_GetStateTranslation(&this->actor.focus.pos);
}

3
src/overlays/actors/ovl_En_Nutsball/z_en_nutsball.c
View File

@ -112,8 +112,7 @@ void EnNutsball_Update(Actor* thisx, GlobalContext* globalCtx) {
spawnBurstPos.x = this->actor.world.pos.x;
spawnBurstPos.y = this->actor.world.pos.y + 4.0f;
spawnBurstPos.z = this->actor.world.pos.z;
EffectSsHahen_SpawnBurst(globalCtx, &spawnBurstPos, 0x40C00000, 0, 7, 3, 15, HAHEN_OBJECT_DEFAULT, 10,
NULL);
EffectSsHahen_SpawnBurst(globalCtx, &spawnBurstPos, 6.0f, 0, 7, 3, 15, HAHEN_OBJECT_DEFAULT, 10, NULL);
if (this->actor.params == 1) {
func_800F0568(globalCtx, &this->actor.world.pos, 20, NA_SE_EV_NUTS_BROKEN);
} else {

15
src/overlays/actors/ovl_En_Pametfrog/z_en_pametfrog.c
View File

@ -174,7 +174,7 @@ void EnPametfrog_Init(Actor* thisx, GlobalContext* globalCtx) {
if (Actor_GetRoomCleared(globalCtx, globalCtx->roomContext.currRoom.num)) {
Actor_MarkForDeath(&this->actor);
if (!(gSaveContext.weekEventReg[isFrogReturnedFlags[this->actor.params - 1] >> 8] &
(u8)isFrogReturnedFlags[this->actor.params - 1])) {
(u8)isFrogReturnedFlags[this->actor.params - 1])) {
Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_MINIFROG, this->actor.world.pos.x,
this->actor.world.pos.y, this->actor.world.pos.z, 0, this->actor.shape.rot.y, 0, this->params);
}
@ -469,7 +469,8 @@ void EnPametfrog_RearOnSnapperRise(EnPametfrog* this, GlobalContext* globalCtx)
if (this->timer == 0) {
EnPametfrog_SetupRearOnSnapper(this);
} else {
this->actor.world.pos.y = Math_SinS(this->timer * 0xCCC) * 100.0f + (((EnBigpamet*)this->actor.child)->unk_2AC + 46.0f);
this->actor.world.pos.y =
Math_SinS(this->timer * 0xCCC) * 100.0f + (((EnBigpamet*)this->actor.child)->unk_2AC + 46.0f);
}
}
@ -505,7 +506,7 @@ void EnPametfrog_FallOffSnapper(EnPametfrog* this, GlobalContext* globalCtx) {
this->timer--;
}
sin = sin_rad(this->timer * (M_PI/3.0f)) * ((0.02f * (this->timer * (1.0f/6.0f))) + 0.005f) + 1.0f;
sin = sin_rad(this->timer * (M_PI / 3.0f)) * ((0.02f * (this->timer * (1.0f / 6.0f))) + 0.005f) + 1.0f;
EnPametfrog_ShakeCamera(this, globalCtx, 300.0f * sin, 100.0f * sin);
if (this->actor.bgCheckFlags & 1) {
EnPametfrog_StopCutscene(this, globalCtx);
@ -643,7 +644,7 @@ void EnPametfrog_SetupWallPause(EnPametfrog* this) {
this->actor.speedXZ = 0.0f;
this->skelAnime.animPlaybackSpeed = 1.5f;
if (this->timer != 0) {
this->wallRotation = this->unk_2E8.y > 0.0f ? (M_PI/30.0f) : (-M_PI/30.0f);
this->wallRotation = this->unk_2E8.y > 0.0f ? (M_PI / 30.0f) : (-M_PI / 30.0f);
} else {
randFloat = Rand_ZeroFloat(0x2000);
this->wallRotation = (Rand_ZeroOne() < 0.5f ? -1 : 1) * (0x1000 + randFloat) * (M_PI / (15 * 0x8000));
@ -959,7 +960,7 @@ void EnPametfrog_SpawnFrog(EnPametfrog* this, GlobalContext* globalCtx) {
f32 magShake;
this->timer--;
magShake = (sin_rad(this->timer * (M_PI/5.0f)) * ((0.04f * (this->timer * 0.1f)) + 0.02f)) + 1.0f;
magShake = (sin_rad(this->timer * (M_PI / 5.0f)) * ((0.04f * (this->timer * 0.1f)) + 0.02f)) + 1.0f;
EnPametfrog_ShakeCamera(this, globalCtx, 75.0f * magShake, 10.0f * magShake);
if (this->timer == 0) {
EnPametfrog_StopCutscene(this, globalCtx);
@ -1212,7 +1213,7 @@ void EnPametfrog_SetupSnapperSpawn(EnPametfrog* this, GlobalContext* globalCtx)
void EnPametfrog_SnapperSpawn(EnPametfrog* this, GlobalContext* globalCtx) {
this->timer--;
EnPametfrog_ShakeCamera(this, globalCtx, (f32)(this->timer * 7.5f) + 200.0f,
((f32)(this->timer * 2) * (15.0f/16.0f)) + -20.0f);
((f32)(this->timer * 2) * (15.0f / 16.0f)) + -20.0f);
if (this->timer != 0) {
func_8013ECE0(this->actor.xyzDistToPlayerSq, 120, 20, 10);
} else {
@ -1338,7 +1339,7 @@ void EnPametfrog_Update(Actor* thisx, GlobalContext* globalCtx) {
unk2C4 = ((this->unk_2C4 + 1.0f) * 0.375f);
this->unk_2C8 = unk2C4;
this->unk_2C8 = unk2C4 > 0.75f ? 0.75f : this->unk_2C8;
} else if (!Math_StepToF(&this->unk_2CC, 0.75f, (3.0f/160.0f))) {
} else if (!Math_StepToF(&this->unk_2CC, 0.75f, (3.0f / 160.0f))) {
func_800B9010(&this->actor, NA_SE_EV_ICE_FREEZE - SFX_FLAG);
}
}

2
src/overlays/actors/ovl_En_Torch2/z_en_torch2.c
View File

@ -77,7 +77,7 @@ void EnTorch2_Destroy(Actor* thisx, GlobalContext* globalCtx) {
EnTorch2* this = THIS;
Collider_DestroyCylinder(globalCtx, &this->collider);
func_80169DCC(globalCtx, this->actor.params + 3, 0xFF, 0, 0xBFF, &this->actor.world, this->actor.shape.rot.y);
func_80169DCC(globalCtx, this->actor.params + 3, 0xFF, 0, 0xBFF, &this->actor.world.pos, this->actor.shape.rot.y);
globalCtx->actorCtx.unk254[this->actor.params] = 0;
}

1
src/overlays/actors/ovl_Obj_Ghaka/z_obj_ghaka.c
View File

@ -46,7 +46,6 @@ extern Gfx D_06001A20[];
extern Gfx D_06001980[];
extern CollisionHeader D_06003CD0;
void func_80B3C260(ObjGhaka* this) {
if (gSaveContext.weekEventReg[20] & 0x20) {
this->dyna.actor.world.pos.z = this->dyna.actor.home.pos.z + 100.0f;

19
src/overlays/actors/ovl_Obj_Kibako/z_obj_kibako.c
View File

@ -79,8 +79,7 @@ void ObjKibako_SpawnCollectible(ObjKibako* this, GlobalContext* globalCtx) {
if (this->isDropCollected == 0) {
collectible = func_800A8150(this->actor.params & 0x3F);
if (collectible >= 0) {
Item_DropCollectible(globalCtx, &this->actor.world.pos,
collectible | GET_KIBAKO_COLLECTIBLE_ID(this));
Item_DropCollectible(globalCtx, &this->actor.world.pos, collectible | GET_KIBAKO_COLLECTIBLE_ID(this));
this->isDropCollected = 1;
}
}
@ -188,10 +187,9 @@ void ObjKibako_AirBreak(ObjKibako* this, GlobalContext* globalCtx) {
phi_s0 = 0x20;
}
EffectSsKakera_Spawn(globalCtx, &pos, &velocity, worldPos, -200, phi_s0, 20, 0, 0,
(Rand_ZeroOne() * 38.0f) + 10.0f, 0, 0, 60, -1,
sObjectIdList[(this->actor.params >> 0xF) & 1],
sKakeraDisplayLists[(this->actor.params >> 0xF) & 1]);
EffectSsKakera_Spawn(
globalCtx, &pos, &velocity, worldPos, -200, phi_s0, 20, 0, 0, (Rand_ZeroOne() * 38.0f) + 10.0f, 0, 0, 60,
-1, sObjectIdList[(this->actor.params >> 0xF) & 1], sKakeraDisplayLists[(this->actor.params >> 0xF) & 1]);
}
func_800BBFB0(globalCtx, worldPos, 40.0f, 3, 0x32, 0x8C, 1);
@ -233,10 +231,9 @@ void ObjKibako_WaterBreak(ObjKibako* this, GlobalContext* globalCtx) {
temp_rand = Rand_ZeroOne();
phi_s0 = (temp_rand < 0.2f) ? 0x40 : 0x20;
EffectSsKakera_Spawn(globalCtx, &pos, &velocity, worldPos, -180, phi_s0, 50, 5, 0,
(Rand_ZeroOne() * 35.0f) + 10.0f, 0, 0, 70, -1,
sObjectIdList[(this->actor.params >> 0xF) & 1],
sKakeraDisplayLists[(this->actor.params >> 0xF) & 1]);
EffectSsKakera_Spawn(
globalCtx, &pos, &velocity, worldPos, -180, phi_s0, 50, 5, 0, (Rand_ZeroOne() * 35.0f) + 10.0f, 0, 0, 70,
-1, sObjectIdList[(this->actor.params >> 0xF) & 1], sKakeraDisplayLists[(this->actor.params >> 0xF) & 1]);
}
}
@ -269,7 +266,7 @@ void ObjKibako_Idle(ObjKibako* this, GlobalContext* globalCtx) {
if (func_800A817C(this->actor.params & 0x3F)) {
ObjKibako_SpawnCollectible(this, globalCtx);
}
func_800B8E58(this, 0x878);
func_800B8E58(&this->actor, NA_SE_PL_PULL_UP_WOODBOX);
} else if ((this->actor.bgCheckFlags & 0x20) && (this->actor.yDistToWater > 19.0f)) {
ObjKibako_WaterBreak(this, globalCtx);
ObjKibako_SpawnCollectible(this, globalCtx);

3
src/overlays/actors/ovl_Obj_Lightswitch/z_obj_lightswitch.c
View File

@ -174,6 +174,7 @@ void ObjLightswitch_SpawnEffects(ObjLightswitch* this, GlobalContext* globalCtx)
}
}
#else
void ObjLightswitch_SpawnEffects(ObjLightswitch* this, GlobalContext* globalCtx);
#pragma GLOBAL_ASM("./asm/non_matchings/overlays/ovl_Obj_Lightswitch_0x8095FBF0/ObjLightswitch_SpawnEffects.asm")
#endif
@ -446,6 +447,7 @@ void ObjLightSwitch_DrawOpa(ObjLightswitch* this, GlobalContext* globalCtx) {
CLOSE_DISPS(globalCtx->state.gfxCtx);
}
#else
void ObjLightSwitch_DrawOpa(ObjLightswitch* this, GlobalContext* globalCtx);
#pragma GLOBAL_ASM("./asm/non_matchings/overlays/ovl_Obj_Lightswitch_0x8095FBF0/ObjLightSwitch_DrawOpa.asm")
#endif
@ -498,6 +500,7 @@ void ObjLightSwitch_DrawXlu(ObjLightswitch* this, GlobalContext* globalCtx) {
CLOSE_DISPS(globalCtx->state.gfxCtx);
}
#else
void ObjLightSwitch_DrawXlu(ObjLightswitch* this, GlobalContext* globalCtx);
#pragma GLOBAL_ASM("./asm/non_matchings/overlays/ovl_Obj_Lightswitch_0x8095FBF0/ObjLightSwitch_DrawXlu.asm")
#endif

8
tables/functions.txt
View File

@ -3363,11 +3363,11 @@
0x801800CC:("Math_Atan2F",),
0x80180100:("Math_FAtan2F",),
0x8018012C:("Math_Acot2F",),
0x80180160:("Matrix_Init",),
0x8018019C:("Matrix_Push",),
0x801801CC:("Matrix_Pop",),
0x80180160:("SysMatrix_StateAlloc",),
0x8018019C:("SysMatrix_StatePush",),
0x801801CC:("SysMatrix_StatePop",),
0x801801E8:("SysMatrix_CopyCurrentState",),
0x8018020C:("Matrix_Put",),
0x8018020C:("SysMatrix_SetCurrentState",),
0x80180234:("SysMatrix_GetCurrentState",),
0x80180244:("SysMatrix_InsertMatrix",),
0x8018029C:("SysMatrix_InsertTranslation",),

4
tools/actorfixer.py
View File

@ -8,6 +8,10 @@ animdict ={
"Actor_GetSwitchFlag": "Flags_GetSwitch",
"atan_flip": "Math_Acot2F",
"atans": "Math_Atan2S",
"Matrix_Pop": "SysMatrix_StatePop",
"Matrix_Push": "SysMatrix_StatePush",
"Matrix_Init": "SysMatrix_StateAlloc",
"Matrix_Put": "SysMatrix_SetCurrentState",
}
def replace_anim(file):