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

z_bgcheck.c (#357) 

* first few functions

* two more almost matching functions

* Rebase to NBS, get it to compile

* BgCheck_RaycastFloorStaticList OK, fix-up some functions

* BgCheck_SphVsStaticWall OK! and a few others

* more z_bgcheck NON_MATCHINGS

* OK more functions, reorganize external reference #defines

* More functions OK, more struct fixes

* More OKs

* Decomp all the way to the end of bgcheck

* All functions attempted

* Rename functions

* formatting, data migration

* Give names to unk structs, rename some structs, fix some non-equivalent functions

* WaterBox_GetSurfaceImpl OK

* BgCheck_ResetPolyCheckTbl OK, improve WaterBox_GetSurface2 codegen, eliminate warnings and clean up source.

* BcCheck3_BgActorInit ->BgCheck3_BgActorInit, fix warnings

* pr change requests

* fix crc maybe

* implement more changes

* implement alf's changes
This commit is contained in:
mzxrules 2021-11-23 11:29:18 -05:00 committed by GitHub
parent 837eb1c806
commit 6b493d3f9d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
74 changed files with 5551 additions and 1293 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

394
include/functions.h
View File

@ -912,199 +912,159 @@ void ActorOverlayTable_FaultPrint(void* arg0, void* arg1); // ActorOverlayTable_
void* ActorOverlayTable_FaultAddrConv(void* arg0, void* arg1); // ActorOverlayTable_FaultAddrConv
void ActorOverlayTable_Init(void); // ActorOverlayTable_Init
void ActorOverlayTable_Cleanup(void); // ActorOverlayTable_Cleanup
void BgCheck_PolygonLinkedListNodeInit(SSNode* node, s16* polyIndex, u16 next);
void BgCheck_PolygonLinkedListResetHead(u16* head);
void BgCheck_ScenePolygonListsNodeInsert(SSNodeList* list, u16* head, s16* polyIndex);
void BgCheck_PolygonLinkedListNodeInsert(DynaSSNodeList* list, u16* head, s16* polyIndex);
void BgCheck_PolygonLinkedListInit(GlobalContext* globalCtx, DynaSSNodeList* list);
void BgCheck_PolygonLinkedListAlloc(GlobalContext* globalCtx, DynaSSNodeList* list, u32 numNodes);
void BgCheck_PolygonLinkedListReset(DynaSSNodeList* list);
u16 BgCheck_AllocPolygonLinkedListNode(DynaSSNodeList* list);
void BgCheck_CreateVec3fFromVertex(Vec3s* vertex, Vec3f* vector);
void BgCheck_CreateVertexFromVec3f(Vec3s* vertex, Vec3f* vector);
float func_800BFD84(CollisionPoly* polygon, f32 param_2, f32 param_3);
s32 func_800BFDEC(CollisionPoly* param_1, CollisionPoly* param_2, u32* param_3, u32* param_4);
s32 BgCheck_PolygonGetMinY(CollisionPoly* polygons, Vec3s* vertices);
void BgCheck_PolygonGetNormal(CollisionPoly* polygon, f32* normalX, f32* normalY, f32* normalZ);
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* 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);
// void func_800C06A8(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5);
// 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* 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);
// void func_800C12A4(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_800C1B68(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_800C1D7C(void);
// void func_800C2008(void);
// void func_800C20F4(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_800C2310(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_TYPE4 param_8);
// void func_800C2460(void);
// void func_800C2514(void);
// void func_800C25E0(void);
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* 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* 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* colCtx, s32 arg2, CollisionPoly** arg3, s32* arg4, Vec3f* pos, Actor* actor, s32 arg7, f32 arg8, s32 arg9);
// void func_800C3F40(void);
f32 func_800C3FA0(CollisionContext* colCtx, CollisionPoly** arg1, Vec3f* arg2);
f32 func_800C4000(GlobalContext* globalCtx, CollisionContext* colCtx, s32* arg2, Vec3f* arg3);
// void func_800C4058(void);
f32 func_800C40B4(CollisionContext* colCtx, CollisionPoly** poly, s32* arg2, Vec3f* arg3);
f32 func_800C411C(CollisionContext* colCtx, CollisionPoly** arg1, s32* arg2, Actor* actor, Vec3f* pos);
f32 func_800C4188(GlobalContext* globalCtx, CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Actor* actor, Vec3f* pos);
// 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);
// void func_800C42A8(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5);
// void func_800C4314(void);
// void func_800C43CC(void);
// 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* colCtx, u32 arg1, Vec3f* arg2, Vec3f* arg3, Vec3f* arg4, f32 arg5, s32* arg6, s32* arg7, DynaPolyActor* arg8, f32 arg9, u8 arg10);
// 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);
// void func_800C4DA4(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_800C4E10(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_800C4F38(void);
// void func_800C4F84(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_800C4FD4(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, UNK_TYPE4 param_11);
// void func_800C5464(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5);
// void func_800C54AC(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_800C5538(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);
s32 func_800C55C4(CollisionContext* colCtx, Vec3f* arg1, Vec3f* arg2, Vec3f* arg3, CollisionPoly** arg4, u32 arg5, u32 arg6, u32 arg7, u32 arg8, u32* arg9);
// void func_800C5650(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, UNK_TYPE4 param_11);
s32 func_800C56E0(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 chkWall, s32 chkFloor, s32 chkCeil, s32 chkOneFace, s32* bgId, Actor* actor, f32 chkDist);
s32 func_800C576C(CollisionContext* colCtx, Vec3f* arg1, Vec3f* arg2, Vec3f* arg3, CollisionPoly** arg4, u32 arg5, u32 arg6, u32 arg7, u32 arg8, u32* arg9);
// void func_800C57F8(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_800C583C(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_800C58C8(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_800C5954(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);
s32 func_800C5A20(CollisionContext* colCtx, Vec3f* arg1, f32 arg2);
s32 func_800C5A64(CollisionContext* colCtx, Vec3f* arg1, f32 arg2);
void BgCheck_ScenePolygonListsInit(SSNodeList* arg0);
void BgCheck_ScenePolygonListsAlloc(GlobalContext* globalCtx, SSNodeList* lists, s32 numNodes, u32 numPolygons);
s32 func_800C5B80(u16* arg0);
u16 BgCheck_ScenePolygonListsReserveNode(SSNodeList* lists);
void BgCheck_ActorMeshParamsInit(ScaleRotPos* params);
void BgCheck_SetActorMeshParams(ScaleRotPos* params, Vec3f* scale, Vec3s* rotation, Vec3f* position);
s32 BgCheck_AreActorMeshParamsEqual(ScaleRotPos* arg0, ScaleRotPos* arg1);
void BgCheck_ActorMeshPolyListsHeadsInit(DynaLookup* lists);
void BgCheck_ActorMeshPolyListsInit(DynaLookup* lists);
void BgCheck_ActorMeshVerticesIndexInit(s16* index);
void BgCheck_ActorMeshWaterboxesIndexInit(s16* index);
void BgCheck_ActorMeshInit(GlobalContext* globalCtx, BgActor* mesh);
void BgCheck_ActorMeshInitFromActor(BgActor* actorMesh, DynaPolyActor* actor, CollisionHeader* header);
s32 BgCheck_HasActorMeshChanged(BgActor* mesh);
void BgCheck_PolygonsInit(CollisionPoly** polygons);
void BgCheck_PolygonsAlloc(GlobalContext* globalCtx, CollisionPoly* polygons, u32 numPolygons);
void BgCheck_VerticesInit(Vec3s** vertices);
void BgCheck_VerticesListAlloc(GlobalContext* globalCtx, Vec3s** vertices, u32 numVertices);
void BgCheck_WaterboxListInit(DynaSSWaterboxList* waterboxList);
void BgCheck_WaterboxListAlloc(GlobalContext* globalCtx, DynaSSWaterboxList* waterboxList, u32 numWaterboxes);
void BgCheck_ActorMeshUpdateParams(GlobalContext* globalCtx, BgActor* mesh);
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* 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);
void func_800C63C4(GlobalContext* globalCtx, DynaCollisionContext* dyna, s32 index);
void func_800C641C(GlobalContext* globalCtx, DynaCollisionContext* dyna, s32 index);
void func_800C6474(GlobalContext* globalCtx, DynaCollisionContext* dyna, s32 index);
void BgCheck_RemoveActorMesh(GlobalContext* globalCtx, DynaCollisionContext* dyna, s32 index);
// void func_800C6554(void);
void SSNode_SetValue(SSNode* node, s16* polyIndex, u16 next);
void SSList_SetNull(SSList* head);
void SSNodeList_SetSSListHead(SSNodeList* list, SSList* ssList, s16* polyIndex);
void DynaSSNodeList_SetSSListHead(DynaSSNodeList* list, SSList* ssList, s16* polyIndex);
void DynaSSNodeList_Init(GlobalContext* globalCtx, DynaSSNodeList* list);
void DynaSSNodeList_Alloc(GlobalContext* globalCtx, DynaSSNodeList* list, u32 numNodes);
void DynaSSNodeList_ResetCount(DynaSSNodeList* list);
u16 DynaSSNodeList_GetNextNodeIdx(DynaSSNodeList* list);
void BgCheck_Vec3sToVec3f(Vec3s* vertex, Vec3f* vector);
void BgCheck_Vec3fToVec3s(Vec3s* vertex, Vec3f* vector);
f32 func_800BFD84(CollisionPoly *poly, f32 arg1, f32 arg2);
s32 func_800BFDEC(CollisionPoly* polyA, CollisionPoly* polyB, u32* outVtxId0, u32* outVtxId1);
s16 CollisionPoly_GetMinY(CollisionPoly* poly, Vec3s* vertices);
void CollisionPoly_GetNormalF(CollisionPoly* poly, f32* nx, f32* ny, f32* nz);
void func_800C0094(CollisionPoly* poly, f32 tx, f32 ty, f32 tz, MtxF* dest);
f32 CollisionPoly_GetPointDistanceFromPlane(CollisionPoly* poly, Vec3f* point);
void CollisionPoly_GetVerticesByBgId(CollisionPoly* poly, s32 bgId, CollisionContext* colCtx, Vec3f* dest);
s32 CollisionPoly_SphVsPoly(CollisionPoly* poly, Vec3s* vtxList, Vec3f* center, f32 radius);
void StaticLookup_AddPolyToSSList(CollisionContext* colCtx, SSList* ssList, CollisionPoly* polyList, Vec3s* vtxList, s16 polyId);
void StaticLookup_AddPoly(StaticLookup* lookup, CollisionContext* colCtx, CollisionPoly* polyList, Vec3s* vtxList, s16 index);
void BgCheck_GetSubdivisionMinBounds(CollisionContext* colCtx, Vec3f* pos, s32* sx, s32* sy, s32* sz);
void BgCheck_GetSubdivisionMaxBounds(CollisionContext* colCtx, Vec3f* pos, s32* sx, s32* sy, s32* sz);
void BgCheck_GetPolySubdivisionBounds(CollisionContext* colCtx, Vec3s* vtxList, CollisionPoly* polyList, s32* subdivMinX, s32* subdivMinY, s32* subdivMinZ, s32* subdivMaxX, s32* subdivMaxY, s32* subdivMaxZ, s16 polyId);
s32 BgCheck_PolyIntersectsSubdivision(Vec3f* min, Vec3f* max, CollisionPoly* polyList, Vec3s* vtxList, s16 polyId);
u32 BgCheck_InitStaticLookup(CollisionContext* colCtx, GlobalContext* globalCtx, StaticLookup* lookupTbl);
s32 BgCheck_IsSmallMemScene(GlobalContext* globalCtx);
s32 BgCheck_TryGetCustomMemsize(s32 sceneId, u32* memSize);
void BgCheck_SetSubdivisionDimension(f32 min, s32 subdivAmount, f32* max, f32* subdivLength, f32* subdivLengthInv);
s32 BgCheck_GetSpecialSceneMaxObjects(GlobalContext* globalCtx, s32* maxNodes, s32* maxPolygons, s32* maxVertices);
void BgCheck_Allocate(CollisionContext* colCtx, GlobalContext* globalCtx, CollisionHeader* colHeader);
void BgCheck_SetContextFlags(CollisionContext* colCtx, u32 flags);
void BgCheck_UnsetContextFlags(CollisionContext* colCtx, u32 flags);
CollisionHeader* BgCheck_GetCollisionHeader(CollisionContext* colCtx, s32 bgId);
f32 BgCheck_RaycastFloorImpl(GlobalContext* globalCtx, CollisionContext* colCtx, u16 xpFlags, CollisionPoly** outPoly, s32* outBgId, Vec3f* pos, Actor* actor, u32 arg7, f32 chkDist, s32 arg9);
f32 BgCheck_CameraRaycastFloor1(CollisionContext* colCtx, CollisionPoly** outPoly, Vec3f* pos);
f32 BgCheck_EntityRaycastFloor1(CollisionContext* colCtx, CollisionPoly** outPoly, Vec3f* pos);
f32 BgCheck_EntityRaycastFloor2(GlobalContext* globalCtx, CollisionContext* colCtx, CollisionPoly** outPoly, Vec3f* pos);
f32 BgCheck_EntityRaycastFloor2_1(GlobalContext* globalCtx, CollisionContext* colCtx, CollisionPoly** outPoly, Vec3f* pos);
f32 BgCheck_EntityRaycastFloor3(CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Vec3f* pos);
f32 BgCheck_EntityRaycastFloor5(CollisionContext* colCtx, CollisionPoly** outPoly, s32* outBgId, Actor* actor, Vec3f* pos);
f32 BgCheck_EntityRaycastFloor5_2(GlobalContext* globalCtx, CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Actor* actor, Vec3f* pos);
f32 BgCheck_EntityRaycastFloor5_3(GlobalContext* globalCtx, CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Actor* actor, Vec3f* pos);
f32 BgCheck_EntityRaycastFloor6(CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Actor* actor, Vec3f* pos, f32 chkDist);
f32 BgCheck_EntityRaycastFloor7(CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Actor* actor, Vec3f* pos);
f32 BgCheck_AnyRaycastFloor1(CollisionContext* colCtx, CollisionPoly* outPoly, Vec3f* pos);
f32 BgCheck_AnyRaycastFloor2(CollisionContext* colCtx, CollisionPoly* outPoly, s32* bgId, Vec3f* pos);
f32 BgCheck_CameraRaycastFloor2(CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Vec3f* pos);
f32 BgCheck_EntityRaycastFloor8(CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Actor* actor, Vec3f* pos);
f32 BgCheck_EntityRaycastFloor9(CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Vec3f* pos);
s32 BgCheck_CheckWallImpl(CollisionContext* colCtx, u16 xpFlags, Vec3f* posResult, Vec3f* posNext, Vec3f* posPrev, f32 radius, CollisionPoly** outPoly, s32* outBgId, Actor* actor, f32 checkHeight, u8 argA);
s32 BgCheck_EntitySphVsWall1(CollisionContext* colCtx, Vec3f* posResult, Vec3f* posNext, Vec3f* posPrev, f32 radius, CollisionPoly** outPoly, f32 checkHeight);
s32 BgCheck_EntitySphVsWall2(CollisionContext* colCtx, Vec3f* posResult, Vec3f* posNext, Vec3f* posPrev, f32 radius, CollisionPoly** outPoly, s32* outBgId, f32 checkHeight);
s32 BgCheck_EntitySphVsWall3(CollisionContext* colCtx, Vec3f* posResult, Vec3f* posNext, Vec3f* posPrev, f32 radius, CollisionPoly** outPoly, s32* outBgId, Actor* actor, f32 checkHeight);
s32 BgCheck_EntitySphVsWall4(CollisionContext* colCtx, Vec3f* posResult, Vec3f* posNext, Vec3f* posPrev, f32 radius, CollisionPoly** outPoly, s32* outBgId, Actor* actor, f32 checkHeight);
s32 BgCheck_CheckCeilingImpl(CollisionContext* colCtx, u16 xpFlags, f32* outY, Vec3f* pos, f32 checkHeight, CollisionPoly** outPoly, s32* outBgId, Actor* actor);
s32 BgCheck_AnyCheckCeiling(CollisionContext* colCtx, f32* outY, Vec3f* pos, f32 checkHeight);
s32 BgCheck_EntityCheckCeiling(CollisionContext* colCtx, f32* outY, Vec3f* pos, f32 checkHeight, CollisionPoly** outPoly, s32* outBgId, Actor* actor);
s32 BgCheck_CameraLineTest1(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 chkWall, s32 chkFloor, s32 chkCeil, s32 chkOneFace, s32* bgId);
s32 BgCheck_CameraLineTest2(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 chkWall, s32 chkFloor, s32 chkCeil, s32 chkOneFace, s32* bgId);
s32 BgCheck_EntityLineTest1(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 chkWall, s32 chkFloor, s32 chkCeil, s32 chkOneFace, s32* bgId);
s32 BgCheck_EntityLineTest2(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 chkWall, s32 chkFloor, s32 chkCeil, s32 chkOneFace, s32* bgId, Actor* actor);
s32 BgCheck_EntityLineTest3(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 chkWall, s32 chkFloor, s32 chkCeil, s32 chkOneFace, s32* bgId, Actor* actor, f32 chkDist);
s32 BgCheck_ProjectileLineTest(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 chkWall, s32 chkFloor, s32 chkCeil, s32 chkOneFace, s32* bgId);
s32 BgCheck_AnyLineTest1(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 chkOneFace);
s32 BgCheck_AnyLineTest2(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 chkWall, s32 chkFloor, s32 chkCeil, s32 chkOneFace);
s32 BgCheck_AnyLineTest3(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 chkWall, s32 chkFloor, s32 chkCeil, s32 chkOneFace, s32* bgId);
s32 BgCheck_SphVsFirstPolyImpl(CollisionContext* colCtx, u16 xpFlags, CollisionPoly** outPoly, s32* outBgId, Vec3f* center, f32 radius, Actor* actor, u16 bciFlags);
s32 BgCheck_SphVsFirstPoly(CollisionContext* colCtx, Vec3f* center, f32 radius);
s32 BgCheck_SphVsFirstWall(CollisionContext* colCtx, Vec3f* center, f32 radius);
void SSNodeList_Init(SSNodeList* this);
void SSNodeList_Alloc(GlobalContext* globalCtx, SSNodeList* this, s32 tblMax, s32 numPolys);
SSNode* SSNodeList_GetNextNode(SSNodeList* this);
u16 SSNodeList_GetNextNodeIdx(SSNodeList* this);
void ScaleRotPos_Init(ScaleRotPos* srp);
void ScaleRotPos_SetValue(ScaleRotPos* srp, Vec3f* scale, Vec3s* rot, Vec3f* pos);
s32 ScaleRotPos_IsEqual(ScaleRotPos* a, ScaleRotPos* b);
void DynaLookup_ResetLists(DynaLookup* dynaLookup);
void DynaLookup_Reset(DynaLookup* dynaLookup);
void DynaLookup_ResetVtxStartIndex(u16* vtxStartIndex);
void DynaLookup_ResetWaterBoxStartIndex(u16* waterBoxStartIndex);
void BgActor_Init(GlobalContext* globalCtx, BgActor* bgActor);
void BgActor_SetActor(BgActor* bgActor, Actor* actor, CollisionHeader* colHeader);
s32 BgActor_IsTransformUnchanged(BgActor* bgActor);
void DynaPoly_NullPolyList(CollisionPoly** polyList);
void DynaPoly_AllocPolyList(GlobalContext* globalCtx, CollisionPoly** polyList, s32 numPolys);
void DynaPoly_NullVtxList(Vec3s** vtxList);
void DynaPoly_AllocVtxList(GlobalContext* globalCtx, Vec3s** vtxList, s32 numVtx);
void DynaPoly_InitWaterBoxList(DynaWaterBoxList* waterBoxList);
void DynaPoly_AllocWaterBoxList(GlobalContext* globalCtx, DynaWaterBoxList* waterBoxList, s32 numWaterBoxes);
void DynaPoly_SetBgActorPrevTransform(GlobalContext* globalCtx, BgActor* bgActor);
s32 DynaPoly_IsBgIdBgActor(s32 bgId);
void DynaPoly_Init(GlobalContext* globalCtx, DynaCollisionContext* dyna);
void DynaPoly_Alloc(GlobalContext* globalCtx, DynaCollisionContext* dyna);
s32 DynaPoly_SetBgActor(GlobalContext* globalCtx, DynaCollisionContext* dyna, Actor* actor, CollisionHeader* colHeader);
DynaPolyActor* DynaPoly_GetActor(CollisionContext* colCtx, s32 bgId);
void func_800C62BC(GlobalContext* globalCtx, DynaCollisionContext* dyna, s32 bgId);
void func_800C6314(GlobalContext* globalCtx, DynaCollisionContext* dyna, s32 bgId);
void func_800C636C(GlobalContext* globalCtx, DynaCollisionContext* dyna, s32 bgId);
void func_800C63C4(GlobalContext* globalCtx, DynaCollisionContext* dyna, s32 bgId);
void func_800C641C(GlobalContext* globalCtx, DynaCollisionContext* dyna, s32 bgId);
void func_800C6474(GlobalContext* globalCtx, DynaCollisionContext* dyna, s32 bgId);
void DynaPoly_DeleteBgActor(GlobalContext* globalCtx, DynaCollisionContext* dyna, s32 bgId);
void BgCheck_CalcWaterboxDimensions(Vec3f* minPos, Vec3f* maxXPos, Vec3f* maxZPos, Vec3s* minPosOut, s16* xLength, s16* zLength);
void BgCheck_AddActorMeshToLists(GlobalContext* globalCtx, DynaCollisionContext* dyna, s32 index, s32* currVertices, s32* currPolygons, s32* currWaterboxes);
void DynaPoly_ExpandSRT(GlobalContext* globalCtx, DynaCollisionContext* dyna, s32 bgId, s32* vtxStartIndex, s32* polyStartIndex, s32* waterBoxStartIndex);
void BgCheck_ResetFlagsIfLoadedActor(GlobalContext* globalCtx, DynaCollisionContext* dyna, Actor* actor);
void BgCheck_Update(GlobalContext* globalCtx, DynaCollisionContext* dyna);
void func_800C756C(s32 param_1, s32* param_2, s32* param_3, s32* param_4);
void BgCheck_UpdateAllActorMeshes(GlobalContext* globalCtx, DynaCollisionContext* dyna);
// void func_800C76EC(void);
// void func_800C7974(void);
// void func_800C7E40(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, UNK_TYPE4 param_11, UNK_TYPE4 param_12);
// void func_800C8580(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_800C87D0(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_800C8A60(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_800C8BD0(void);
// void func_800C8DC0(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, UNK_TYPE4 param_11);
// void func_800C8EEC(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, UNK_TYPE4 param_11);
// void func_800C90AC(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_800C921C(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_TYPE4 param_8);
// 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* colCtx, GlobalContext* globalCtx);
// void func_800C9640(void);
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* colCtx, CollisionPoly* polygon, s32 index);
// void func_800C97F8(void);
// UNK_TYPE4 func_800C9844(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
// void func_800C98CC(void);
// 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);
s32 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* colCtx, CollisionPoly* polygon, s32 index);
u32 func_800C9E40(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
u32 func_800C9E88(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
s32 func_800C9EBC(GlobalContext* globalCtx, CollisionContext* colCtx, f32 x, f32 z, f32* ySurface, WaterBox** outWaterBox, s32* bgId);
s32 func_800CA1AC(GlobalContext* globalCtx, CollisionContext* colCtx, f32 x, f32 z, f32* ySurface, WaterBox** outWaterBox);
s32 func_800CA1E8(GlobalContext* globalCtx, CollisionContext* colCtx, f32 x, f32 z, f32* ySurface, WaterBox** outWaterBox);
// 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);
// void func_800CA648(void);
// void func_800CA6B8(void);
// void func_800CA6D8(void);
// 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 DynaPoly_Setup(GlobalContext* globalCtx, DynaCollisionContext* dyna);
void func_800C756C(DynaCollisionContext* dyna, s32* numPolygons, s32* numVertices, s32* numWaterBoxes);
void DynaPoly_UpdateBgActorTransforms(GlobalContext* globalCtx, DynaCollisionContext* dyna);
void CollisionHeader_SegmentedToVirtual(CollisionHeader* header);
void CollisionHeader_GetVirtual(CollisionHeader* meshSegPtr, CollisionHeader** param_2);
void BgCheck_InitCollisionHeaders(CollisionContext* colCtx, GlobalContext* globalCtx);
u32 SurfaceType_GetData(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId, s32 dataIdx);
u32 SurfaceType_GetCamDataIndex(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
u16 SurfaceType_GetCameraSType(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
u16 SurfaceType_GetNumCameras(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
Vec3s* SurfaceType_GetCamPosData(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
u32 SurfaceType_GetSceneExitIndex(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
u32 func_800C99D4(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
u32 func_800C99FC(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
u32 func_800C9A24(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
s32 func_800C9A4C(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
s32 func_800C9A7C(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
s32 func_800C9AB0(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
s32 func_800C9AE4(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
u32 func_800C9B18(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
u32 func_800C9B40(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
u32 func_800C9B68(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
u32 SurfaceType_IsHorseBlocked(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
u32 func_800C9BB8(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
u16 SurfaceType_GetSfx(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
s32 func_800C9C24(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId, s32 arg3);
u32 SurfaceType_GetSlope(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
u32 SurfaceType_GetLightSettingIndex(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
u32 SurfaceType_GetEcho(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
u32 SurfaceType_IsHookshotSurface(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
s32 SurfaceType_IsIgnoredByEntities(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
s32 SurfaceType_IsIgnoredByProjectiles(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
s32 SurfaceType_IsConveyor(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
s32 func_800C9DDC(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
u32 SurfaceType_GetConveyorSpeed(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
u32 SurfaceType_GetConveyorDirection(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
u32 SurfaceType_IsWallDamage(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
s32 WaterBox_GetSurfaceImpl(GlobalContext* globalCtx, CollisionContext* colCtx, f32 x, f32 z, f32* ySurface, WaterBox** outWaterBox, s32* bgId);
s32 WaterBox_GetSurface1(GlobalContext* globalCtx, CollisionContext* colCtx, f32 x, f32 z, f32* ySurface, WaterBox** outWaterBox);
s32 WaterBox_GetSurface1_2(GlobalContext* globalCtx, CollisionContext* colCtx, f32 x, f32 z, f32* ySurface, WaterBox** outWaterBox);
s32 WaterBox_GetSurface2(GlobalContext* globalCtx, CollisionContext* colCtx, Vec3f* pos, f32 surfaceChkDist, WaterBox** outWaterBox, s32* bgId);
f32 func_800CA568(CollisionContext* colCtx, s32 waterBoxId, s32 bgId);
u16 WaterBox_GetCameraSType(CollisionContext* colCtx, WaterBox* waterBox, s32 bgId);
void func_800CA6B8(CollisionContext* colCtx, WaterBox* waterBox);
u32 WaterBox_GetLightSettingIndex(CollisionContext* colCtx, WaterBox* waterBox);
s32 func_800CA6F0(GlobalContext* globalCtx, CollisionContext* colCtx, f32 x, f32 z, f32* ySurface, WaterBox** outWaterBox, s32* bgId);
s32 func_800CA9D0(GlobalContext* globalCtx, CollisionContext* colCtx, f32 x, f32 z, f32* ySurface, WaterBox** outWaterBox);
s32 func_800CAA14(CollisionPoly* polyA, CollisionPoly* polyB, Vec3f* pointA, Vec3f* pointB, Vec3f* closestPoint);
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);
@ -3269,7 +3229,7 @@ f32 cos_rad(f32 rad);
f32 Rand_ZeroFloat(f32 scale);
f32 randPlusMinusPoint5Scaled(f32 scale);
f32 Math3D_Normalize(Vec3f* vec);
// UNK_TYPE4 func_80179678(f32 fParm1, f32 fParm2, f32 fParm5, f32 param_4, f32 param_5, f32 param_6, f32 param_7, UNK_TYPE4 param_8, UNK_TYPE4 param_9, UNK_TYPE4 param_10, UNK_TYPE4 param_11);
s32 Math3D_PlaneVsLineSegClosestPoint(f32 planeAA, f32 planeAB, f32 planeAC, f32 planeADist, f32 planeBA, f32 planeBB, f32 planeBC, f32 planeBDist, Vec3f* linePointA, Vec3f* linePointB, Vec3f* closestPoint);
// UNK_TYPE4 func_80179798(Vec3f* param_1, Vec3f* param_2, Vec3f* param_3, Vec3f* param_4, Vec3f* param_5, Vec3f* param_6);
// void func_80179A44(void);
void func_80179B34(float fParm1, f32 fParm2, f32 fParm5, f32 fParm6, f32 param_5, f32 param_6, f32 param_7, float* param_8, float* param_9);
@ -3283,7 +3243,7 @@ void func_80179F64(Vec3f* param_1, Vec3f* param_2, Vec3f* param_3);
s32 Math3D_XZBoundCheck(f32 xMin, f32 xMax, f32 zMin, f32 zMax, f32 x, f32 z);
// void func_8017A09C(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_8017A1D0(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_8017A304(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
s32 func_8017A304(Vec3f* v0, Vec3f* v1, Vec3f* v2, f32 z, f32 x, f32 chkDist);
// UNK_TYPE4 func_8017A438(Vec3f* pfParm1, Vec3f* pfParm2, Vec3f* pfParm3, Vec3f* pfParm4, f32 param_5);
f32 Math3D_XZLengthSquared(f32 x, f32 z);
f32 Math3D_XZLength(f32 x, f32 z);
@ -3291,46 +3251,46 @@ f32 Math3D_XZDistanceSquared(f32 x1, f32 x2, f32 z1, f32 z2);
f32 Math3D_XZDistance(f32 x1, f32 x2, f32 z1, f32 z2);
f32 Math3D_LengthSquared(Vec3f* vec);
f32 Math3D_Vec3fMagnitude(Vec3f* vec);
f32 Math3D_DistanceSquared(Vec3f* a, Vec3f* b);
f32 Math3D_Vec3fDistSq(Vec3f* a, Vec3f* b);
f32 Math3D_Distance(Vec3f* a, Vec3f* b);
f32 Math3D_DistanceS(Vec3s* s, Vec3f* f);
f32 func_8017A7B8(f32* param_1, f32* param_2, f32 param_3, f32 param_4);
f32 func_8017A7F8(f32* param_1, f32* param_2, f32 param_3, f32 param_4);
f32 func_8017A838(f32* param_1, f32* param_2, f32 param_3, f32 param_4);
void Math3D_CrossProduct(Vec3f* a, Vec3f* b, Vec3f* res);
void Math3D_NormalVector(Vec3f* a, Vec3f* b, Vec3f* c, Vec3f* res);
u32 func_8017A954(Vec3f* param_1, Vec3f* param_2, Vec3f* param_3);
u32 func_8017AA0C(Vec3f* param_1, Vec3f* param_2, Vec3f* param_3);
u32 func_8017ABBC(Vec3f* param_1, Vec3f* param_2, Vec3f* param_3);
// void func_8017AD38(void);
void Math3D_SurfaceNorm(Vec3f* a, Vec3f* b, Vec3f* c, Vec3f* res);
u32 Math3D_PointRelativeToCubeFaces(Vec3f* param_1, Vec3f* param_2, Vec3f* param_3);
u32 Math3D_PointRelativeToCubeEdges(Vec3f* param_1, Vec3f* param_2, Vec3f* param_3);
u32 Math3D_PointRelativeToCubeVertices(Vec3f* param_1, Vec3f* param_2, Vec3f* param_3);
s32 Math3D_LineVsCube(Vec3f* min, Vec3f* max, Vec3f* a, Vec3f* b);
// void func_8017B68C(void);
void func_8017B7F8(Vec3f* arg0, s16 arg1, f32* arg2, f32* arg3, f32* arg4);
void Math3D_UnitNormalVector(Vec3f* a, Vec3f* b, Vec3f* c, f32* normX, f32* normY, f32* normZ, f32* param_7);
f32 Math3D_SignedDistanceFromPlane(f32 normX, f32 normY, f32 normZ, f32 d, Vec3f* position);
// void func_8017B9D8(void);
f32 Math3D_NormalizedDistanceFromPlane(f32 normX, f32 normY, f32 normZ, f32 d, Vec3f* position);
f32 Math3D_NormalizedSignedDistanceFromPlane(f32 normX, f32 normY, f32 normZ, f32 d, Vec3f* position);
// void func_8017BAD0(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);
f32 Math3D_UDistPlaneToPos(f32 normX, f32 normY, f32 normZ, f32 d, Vec3f* position);
f32 Math3D_DistPlaneToPos(f32 normX, f32 normY, f32 normZ, f32 d, Vec3f* position);
s32 Math3D_TriChkPointParaYDist(Vec3f* v0, Vec3f* v1, Vec3f* v2, f32 y, f32 z, f32 unk, f32 chkDist, f32 ny);
// void func_8017BD98(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_8017BDE0(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5);
// void func_8017BE30(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, UNK_TYPE4 param_11);
// void func_8017BEE0(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, UNK_TYPE4 param_11);
s32 Math3D_TriChkPointParaYIntersectDist(Vec3f* a, Vec3f* b, Vec3f* c, f32 nx, f32 ny, f32 nz, f32 dist, f32 z, f32 x, f32* yIntersect, f32 chkDist);
s32 Math3D_TriChkPointParaYIntersectInsideTri(Vec3f* v0, Vec3f* v1, Vec3f* v2, f32 nx, f32 ny, f32 nz, f32 originDist, f32 z, f32 x, f32* yIntersect, f32 chkDist);
// void func_8017BF8C(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_8017C008(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, UNK_TYPE4 param_11, UNK_TYPE4 param_12);
s32 Math3D_TriChkLineSegParaYIntersect(Vec3f* v0, Vec3f* v1, Vec3f* v2, f32 nx, f32 ny, f32 nz, f32 originDist, f32 z, f32 x, f32* yIntersect, f32 y0, f32 y1);
// void func_8017C17C(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_8017C1F0(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_8017C494(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, UNK_TYPE4 param_11);
// void func_8017C540(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);
s32 Math3D_TriChkPointParaYIntersectInsideTri2(Vec3f* v0, Vec3f* v1, Vec3f* v2, f32 nx, f32 ny, f32 nz, f32 originDist, f32 z, f32 x, f32* yIntersect, f32 chkDist);
s32 Math3D_TriChkPointParaXDist(Vec3f* v0, Vec3f* v1, Vec3f* v2, f32 y, f32 z, f32 unk, f32 chkDist, f32 nx);
// void func_8017C808(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_8017C850(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);
s32 Math3D_TriChkPointParaXIntersect(Vec3f* a, Vec3f* b, Vec3f* c, f32 nx, f32 ny, f32 nz, f32 dist, f32 y, f32 z, f32* xIntersect);
// void func_8017C904(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_8017C980(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, UNK_TYPE4 param_11, UNK_TYPE4 param_12);
s32 Math3D_TriChkLineSegParaXIntersect(Vec3f* v0, Vec3f* v1, Vec3f* v2, f32 nx, f32 ny, f32 nz, f32 originDist, f32 y, f32 z, f32* xIntersect, f32 x0, f32 x1);
// void func_8017CB08(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_8017CB7C(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);
s32 Math3D_TriChkLineSegParaZDist(Vec3f* v0, Vec3f* v1, Vec3f* v2, f32 y, f32 z, f32 unk, f32 chkDist, f32 nz);
// void func_8017CEA8(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_8017CEF0(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);
s32 Math3D_TriChkPointParaZIntersect(Vec3f* a, Vec3f* b, Vec3f* c, f32 nx, f32 ny, f32 nz, f32 dist, f32 x, f32 y, f32* zIntersect);
// void func_8017CFA4(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_8017D020(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, UNK_TYPE4 param_11, UNK_TYPE4 param_12);
s32 Math3D_TriChkLineSegParaZIntersect(Vec3f* v0, Vec3f* v1, Vec3f* v2, f32 nx, f32 ny, f32 nz, f32 originDist, f32 x, f32 y, f32* zIntersect, f32 z0, f32 z1);
// void func_8017D1AC(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_8017D220(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5);
// void func_8017D2FC(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);
@ -3342,14 +3302,14 @@ u32 Math3D_IsPointInSphere(Sphere16* sphere, Vec3f* point);
// void func_8017D814(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5);
// void func_8017D91C(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5);
// void func_8017DA24(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5);
s32 Math3D_ColSphereLineSeg(Sphere16* sphere, LineSegment* line);
s32 Math3D_LineVsSph(Sphere16* sphere, LineSegment* line);
void func_8017DD34(Sphere16* sphere, TriNorm* tri, Vec3f* pfParm3);
s32 Math3D_ColSphereTri(Sphere16* sphere, TriNorm* tri, Vec3f* uParm3);
// void func_8017E294(void);
UNK_TYPE func_8017E350(UNK_PTR, Vec3f*, Vec3f*, Vec3f*, Vec3f*);
s32 Math3D_ColCylinderTri(Cylinder16* cylinder, TriNorm* tri, Vec3f* pzParm3);
// void func_8017F1A0(void);
s32 Math3D_ColSphereSphere(Sphere16* sphere1, Sphere16* sphere2);
s32 Math3D_SphVsSph(Sphere16* sphere1, Sphere16* sphere2);
s32 Math3D_ColSphereSphereIntersect(Sphere16* sphere1, Sphere16* sphere2, f32* intersectAmount);
s32 Math3D_ColSphereSphereIntersectAndDistance(Sphere16* sphere1, Sphere16* sphere2, f32* intersectAmount, f32* dist);
s32 Math3D_ColSphereCylinderDistance(Sphere16* sphere, Cylinder16* cylinder, f32* dist);
@ -3357,9 +3317,9 @@ s32 Math3D_ColSphereCylinderDistanceAndAmount(Sphere16* sphere, Cylinder16* cyli
s32 Math3D_ColCylinderCylinderAmount(Cylinder16* cylinder1, Cylinder16* cylinder2, f32* intersectAmount);
s32 Math3D_ColCylinderCylinderAmountAndDistance(Cylinder16* cylinder1, Cylinder16* cylinder2, f32* intersectAmount, f32* dist);
s32 Math3d_ColTriTri(TriNorm* tri1, TriNorm* tri2, Vec3f* uParm3);
// void func_8017F9C0(void);
// void func_8017FA34(void);
// void func_8017FAA8(void);
s32 Math3D_XZInSphere(Sphere16* sphere, f32 x, f32 z);
s32 Math3D_XYInSphere(Sphere16* sphere, f32 x, f32 y);
s32 Math3D_YZInSphere(Sphere16* sphere, f32 y, f32 z);
// void func_8017FB1C(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, UNK_TYPE4 param_11);
// void func_8017FD44(void);
u16 Math_GetAtan2Tbl(f32 opposite, f32 adjacent);

35
include/variables.h
View File

@ -442,14 +442,8 @@ extern Gfx D_801AEFA0[];
// extern UNK_TYPE1 D_801AEFC0;
extern ActorOverlay gActorOverlayTable[ACTOR_ID_MAX];
extern s32 gMaxActorId;
extern u32 D_801B4620[32];
extern u16 D_801B46A0[16];
extern u8 D_801B46C0[16];
extern s16 bgSpecialSceneParamsDefault[1];
// extern UNK_TYPE1 D_801B46D2;
extern BgSpecialSceneMaxMemory bgSpecialSceneMaxMemory[1];
extern BgSpecialSceneMeshSubdivision bgSpecialSceneMeshSubdivisions[3];
extern BgSpecialSceneMaxObjects bgSpecialSceneMaxObjects[1];
extern BgCheckSceneSubdivisionEntry sSceneSubdivisionList[];
extern BgSpecialSceneMaxObjects sCustomDynapolyMem[];
// extern UNK_TYPE1 D_801B4708;
// extern UNK_TYPE1 D_801B4710;
// extern UNK_TYPE1 D_801B4738;
@ -3139,28 +3133,15 @@ extern FaultClient D_801ED930;
extern FaultAddrConvClient D_801ED940;
extern char D_801ED950[80];
extern char D_801ED9A0[80];
extern Vec3f D_801ED9F0;
extern Vec3f D_801ED9FC;
extern Vec3f D_801EDA08;
extern Vec3f D_801EDA18;
extern Vec3f D_801EDA24;
extern Vec3f D_801EDA30;
extern Vec3f D_801ED9F0[3];
extern Vec3f D_801EDA18[3];
extern MtxF D_801EDA40;
extern Vec3f D_801EDA80;
extern Vec3f D_801EDA8C;
extern Vec3f D_801EDA98;
extern Vec3f D_801EDA80[3];
extern char D_801EDAA8[80];
extern char D_801EDAF8[80];
extern Vec3f D_801EDB48;
extern Vec3f D_01EDB54;
extern Vec3f D_01EDB60;
extern Vec3f D_01EDB70;
extern Vec3f D_801EDB7C;
extern Vec3f D_801EDB88;
extern f32 D_801EDB98;
extern f32 D_801EDB9C;
extern f32 D_801EDBA0;
// extern UNK_TYPE1 D_801EDBA4;
extern Vec3f D_801EDB48[3];
extern Vec3f D_801EDB70[3];
extern Plane D_801EDB98;
extern Sphere16 D_801EDBA8;
extern TriNorm D_801EDBB0;
// extern UNK_TYPE1 D_801EDBD4;

66
include/z64.h
View File

@ -76,13 +76,6 @@ typedef struct {
/* 0xF */ u8 letterboxSize;
} ActorCutscene; // size = 0x10
typedef struct {
/* 0x0 */ s16 polyStartIndex;
/* 0x2 */ s16 ceilingNodeHead;
/* 0x4 */ s16 wallNodeHead;
/* 0x6 */ s16 floorNodeHead;
} ActorMeshPolyLists; // size = 0x8
typedef struct {
/* 0x0 */ s8 segment;
/* 0x2 */ s16 type;
@ -103,49 +96,6 @@ typedef struct {
/* 0x08 */ void* end;
} PolygonType2; // size = 0xC
typedef struct {
/* 0x0 */ u16 floorHead;
/* 0x2 */ u16 wallHead;
/* 0x4 */ u16 ceilingHead;
} BgMeshSubdivision; // size = 0x6
typedef struct {
/* 0x0 */ u32 attributes[2];
} BgPolygonAttributes; // size = 0x8
typedef struct {
/* 0x0 */ s16 polyIndex;
/* 0x2 */ u16 next;
} BgPolygonLinkedListNode; // size = 0x4
typedef struct {
/* 0x0 */ u16 maxNodes;
/* 0x2 */ u16 reservedNodes;
/* 0x4 */ BgPolygonLinkedListNode* nodes;
/* 0x8 */ u8* unk8;
} BgScenePolygonLists; // size = 0xC
typedef struct {
/* 0x0 */ s16 sceneNumber;
/* 0x2 */ UNK_TYPE1 pad2[0x2];
/* 0x4 */ u32 maxMemory;
} BgSpecialSceneMaxMemory; // size = 0x8
typedef struct {
/* 0x0 */ s16 sceneId;
/* 0x2 */ s16 maxNodes;
/* 0x4 */ s16 maxPolygons;
/* 0x6 */ s16 maxVertices;
} BgSpecialSceneMaxObjects; // size = 0x8
typedef struct {
/* 0x0 */ s16 sceneNumber;
/* 0x2 */ s16 xSubdivisions;
/* 0x4 */ s16 ySubdivisions;
/* 0x6 */ s16 zSubdivisions;
/* 0x8 */ s32 unk8;
} BgSpecialSceneMeshSubdivision; // size = 0xC
typedef struct {
/* 0x0 */ s16 func;
/* 0x2 */ UNK_TYPE1 pad2[0x6];
@ -459,18 +409,6 @@ typedef struct {
/* 0x1A */ s16 unk1A;
} s80874650; // size = 0x1C
typedef struct {
/* 0x00 */ Vec3f scale;
/* 0x0C */ Vec3s rotation;
/* 0x14 */ Vec3f pos;
} ActorMeshParams; // size = 0x20
typedef struct {
/* 0x0 */ BgPolygonLinkedListNode* nodes;
/* 0x4 */ u32 nextFreeNode;
/* 0x8 */ s32 maxNodes;
} BgPolygonLinkedList; // size = 0xC
typedef struct {
/* 0x00 */ f32 x[4];
/* 0x10 */ f32 y[4];
@ -478,10 +416,6 @@ typedef struct {
/* 0x30 */ f32 w[4];
} z_Matrix; // size = 0x40
typedef struct {
/* 0x0 */ Vec3s pos;
} BgVertex; // size = 0x6
typedef union {
F3DVertexColor color;
F3DVertexNormal normal;

247
include/z64bgcheck.h
View File

@ -1,10 +1,12 @@
#ifndef _Z_BGCHECK_
#define _Z_BGCHECK_
#ifndef Z64_BGCHECK_H
#define Z64_BGCHECK_H
struct GlobalContext;
struct Actor;
struct DynaPolyActor;
#define SS_NULL 0xFFFF
#define COLPOLY_NORMAL_FRAC (1.0f / SHT_MAX)
#define COLPOLY_SNORMAL(x) ((s16)((x) * SHT_MAX))
#define COLPOLY_GET_NORMAL(n) ((n)*COLPOLY_NORMAL_FRAC)
@ -15,24 +17,54 @@ struct DynaPolyActor;
#define BGACTOR_NEG_ONE -1
#define BG_ACTOR_MAX 50
#define DYNA_WATERBOX_MAX 30
#define BGCHECK_SCENE BG_ACTOR_MAX
#define BGCHECK_Y_MAX 32000.0f
#define BGCHECK_Y_MIN -32000.0f
#define BGCHECK_XYZ_ABSMAX 32760.0f
#define BGCHECK_SUBDIV_OVERLAP 50
#define BGCHECK_SUBDIV_MIN 150.0f
#define FUNC_80041EA4_RESPAWN 5
#define FUNC_80041EA4_MOUNT_WALL 6
#define FUNC_80041EA4_STOP 8
#define FUNC_80041EA4_VOID_OUT 12
#define WATERBOX_ROOM(p) ((((s32)p) >> 13) & 0x3F)
#define WATERBOX_ROOM(p) ((p >> 13) & 0x3F)
// bccFlags (bgcheck check flags)
#define BGCHECK_CHECK_WALL (1 << 0)
#define BGCHECK_CHECK_FLOOR (1 << 1)
#define BGCHECK_CHECK_CEILING (1 << 2)
#define BGCHECK_CHECK_ONE_FACE (1 << 3)
#define BGCHECK_CHECK_DYNA (1 << 4)
#define BGCHECK_CHECK_ALL \
(BGCHECK_CHECK_WALL | BGCHECK_CHECK_FLOOR | BGCHECK_CHECK_CEILING | BGCHECK_CHECK_ONE_FACE | BGCHECK_CHECK_DYNA)
// bciFlags (bgcheck ignore flags)
#define BGCHECK_IGNORE_NONE 0
#define BGCHECK_IGNORE_CEILING (1 << 0)
#define BGCHECK_IGNORE_WALL (1 << 1)
#define BGCHECK_IGNORE_FLOOR (1 << 2)
// xpFlags (poly exclusion flags)
#define COLPOLY_IGNORE_NONE 0
#define COLPOLY_IGNORE_CAMERA (1 << 0)
#define COLPOLY_IGNORE_ENTITY (1 << 1)
#define COLPOLY_IGNORE_PROJECTILES (1 << 2)
// Surface Types
#define COLPOLY_SURFACE_GROUND 0
#define COLPOLY_SURFACE_SAND 1
#define COLPOLY_SURFACE_SNOW 14
// CollisionContext flags
#define BGCHECK_FLAG_REVERSE_CONVEYOR_FLOW 1
typedef struct {
Vec3f scale;
Vec3s rot;
Vec3f pos;
} ScaleRotPos;
/* 0x0 */ Vec3s pos;
} BgVertex; // size = 0x6
typedef struct {
/* 0x00 */ Vec3f scale;
/* 0x0C */ Vec3s rot;
/* 0x14 */ Vec3f pos;
} ScaleRotPos; // size = 0x20
typedef struct CollisionPoly {
/* 0x00 */ u16 type;
@ -53,30 +85,44 @@ typedef struct CollisionPoly {
typedef struct {
/* 0x00 */ u16 cameraSType;
/* 0x02 */ s16 numCameras;
/* 0x02 */ s16 unk_02;
/* 0x04 */ Vec3s* camPosData;
} CamData;
typedef struct {
/* 0x00 */ s16 xMin;
/* 0x02 */ s16 ySurface;
/* 0x04 */ s16 zMin;
/* 0x06 */ s16 xLength;
/* 0x08 */ s16 zLength;
/* 0x0C */ u32 properties;
/* 0x0 */ Vec3s minPos;
/* 0x6 */ s16 xLength;
/* 0x8 */ s16 zLength;
/* 0xC */ u32 properties;
// 0x0008_0000 = ?
// 0x0007_E000 = Room Index, 0x3F = all rooms
// 0x0000_1F00 = Lighting Settings Index
// 0x0007_E000 = room index, 0x3F = all rooms
// 0x0000_1F00 = lighting setting index
// 0x0000_00FF = CamData index
} WaterBox; // size = 0x10
typedef struct {
u32 data[2];
/* 0x0 */ u32 data[2];
// Type 1
// Word 0
// 0x8000_0000 = horse blocked
// 0x4000_0000 = floor surface recessed by 1 unit
// 0x3C00_0000 = ? (floor property?)
// 0x03E0_0000 = ? (wall property?)
// 0x001C_0000 = ?
// 0x0003_E000 = ?
// 0x0000_1F00 = scene exit index
// 0x0000_00FF = CamData index
// Word 1
// 0x0800_0000 = wall damage
} SurfaceType;
// 0x07E0_0000 = conveyor direction
// 0x001C_0000 = conveyor speed
// 0x0002_0000 = is hookable surface
// 0x0001_F800 = echo/reverb
// 0x0000_07C0 = lighting setting index
// 0x0000_0030 = surface slope
// 0x0000_000F = type
} SurfaceType; // size = 0x8
typedef struct {
/* 0x00 */ Vec3s minBounds; // minimum coordinates of poly bounding box
@ -89,49 +135,54 @@ typedef struct {
/* 0x20 */ CamData* cameraDataList;
/* 0x24 */ u16 numWaterBoxes;
/* 0x28 */ WaterBox* waterBoxes;
} CollisionHeader; // original name: BGDataInfo
} CollisionHeader; // size = 0x2C
typedef struct {
s16 polyId;
u16 next; // next SSNode index
} SSNode;
/* 0x0 */ s16 polyId;
/* 0x2 */ u16 next; // index of the next SSNode in the list, or SS_NULL if last element
} SSNode; // size = 0x4
typedef struct {
u16 head; // first SSNode index
} SSList;
u16 head; // index of the first SSNode in the list, or SS_NULL if the list is empty
} SSList; // represents a linked list of type SSNode
typedef struct {
/* 0x00 */ u16 max; // original name: short_slist_node_size
/* 0x02 */ u16 count; // original name: short_slist_node_last_index
/* 0x04 */ SSNode* tbl; // original name: short_slist_node_tbl
/* 0x08 */ u8* polyCheckTbl; // points to an array of bytes, one per static poly. Zero initialized when starting a
// bg check, and set to 1 if that poly has already been tested.
} SSNodeList;
/* 0x0 */ u16 max;
/* 0x2 */ u16 count;
/* 0x4 */ SSNode* tbl;
/* 0x8 */ u8* polyCheckTbl;
} SSNodeList; // size = 0xC
typedef struct {
SSNode* tbl;
s32 count;
s32 max;
} DynaSSNodeList;
/* 0x0 */ SSNode* tbl;
/* 0x4 */ u32 count;
/* 0x8 */ s32 maxNodes;
} DynaSSNodeList; // size = 0xC
typedef struct {
SSList floor;
SSList wall;
SSList ceiling;
} StaticLookup;
/* 0x0 */ s32 unk0;
/* 0x4 */ WaterBox* boxes;
} DynaWaterBoxList; // size = 0x8
typedef struct {
u16 polyStartIndex;
SSList ceiling;
SSList wall;
SSList floor;
} DynaLookup;
/* 0x0 */ SSList floor;
/* 0x2 */ SSList wall;
/* 0x4 */ SSList ceiling;
} StaticLookup; // size = 0x6
typedef struct {
/* 0x00 */ struct Actor* actor;
/* 0x0 */ s16 polyStartIndex;
/* 0x2 */ SSList ceiling;
/* 0x4 */ SSList wall;
/* 0x6 */ SSList floor;
} DynaLookup; // size = 0x8
typedef struct {
/* 0x00 */ Actor* actor;
/* 0x04 */ CollisionHeader* colHeader;
/* 0x08 */ DynaLookup dynaLookup;
/* 0x10 */ u16 vtxStartIndex;
/* 0x12 */ u16 waterboxesStartIndex;
/* 0x14 */ ScaleRotPos prevTransform;
/* 0x34 */ ScaleRotPos curTransform;
/* 0x54 */ Sphere16 boundingSphere;
@ -139,25 +190,20 @@ typedef struct {
/* 0x60 */ f32 maxY;
} BgActor; // size = 0x64
typedef struct {
/* 0x0 */ UNK_TYPE1 pad0[0x4];
/* 0x4 */ WaterBox* boxes;
} DynaSSWaterboxList; // size = 0x8
typedef struct {
/* 0x0000 */ u8 bitFlag;
/* 0x0004 */ BgActor bgActors[BG_ACTOR_MAX];
/* 0x138C */ u16 bgActorFlags[BG_ACTOR_MAX]; // & 0x0008 = no dyna ceiling
/* 0x138C */ u16 bgActorFlags[BG_ACTOR_MAX]; // bit 0 - Is mesh active
/* 0x13F0 */ CollisionPoly* polyList;
/* 0x13F4 */ Vec3s* vtxList;
/* 0x13F8 */ DynaSSWaterboxList waterboxes;
/* 0x13F8 */ DynaWaterBoxList waterBoxList;
/* 0x1400 */ DynaSSNodeList polyNodes;
/* 0x140C */ s32 polyNodesMax;
/* 0x1410 */ s32 polyListMax;
/* 0x1414 */ s32 vtxListMax;
} DynaCollisionContext; // size = 0x1418
typedef struct CollisionContext {
typedef struct {
/* 0x00 */ CollisionHeader* colHeader; // scene's static collision
/* 0x04 */ Vec3f minBounds; // minimum coordinates of collision bounding box
/* 0x10 */ Vec3f maxBounds; // maximum coordinates of collision bounding box
@ -166,28 +212,46 @@ typedef struct CollisionContext {
/* 0x34 */ Vec3f subdivLengthInv; // inverse of subdivision length
/* 0x40 */ StaticLookup* lookupTbl; // 3d array of length subdivAmount
/* 0x44 */ SSNodeList polyNodes;
/* 0x50 */ DynaCollisionContext dyna;
/* 0x1460 */ u32 memSize; // Size of all allocated memory plus CollisionContext
/* 0x146C */ u32 unk146C;
/* 0x0050 */ DynaCollisionContext dyna;
/* 0x1468 */ u32 memSize; // Size of all allocated memory plus CollisionContext
/* 0x146C */ u32 flags; // bit 0 reverses conveyor direction (i.e. water flow in Great Bay Temple)
} CollisionContext; // size = 0x1470
typedef struct {
/* 0x00 */ struct GlobalContext* globalCtx;
/* 0x04 */ struct CollisionContext* colCtx;
/* 0x04 */ CollisionContext* colCtx;
/* 0x08 */ u16 xpFlags;
/* 0x0C */ CollisionPoly** resultPoly;
/* 0x10 */ f32 yIntersect;
/* 0x14 */ Vec3f* pos;
/* 0x18 */ s32* bgId;
/* 0x1C */ struct Actor* actor;
/* 0x20 */ u32 unk_20;
/* 0x24 */ f32 chkDist;
/* 0x28 */ DynaCollisionContext* dyna;
/* 0x2C */ SSList* ssList;
} DynaRaycast;
/* 0x1C */ s32 unk1C;
/* 0x20 */ struct Actor* actor;
/* 0x24 */ u32 unk_24;
/* 0x28 */ f32 checkDist;
/* 0x2C */ DynaCollisionContext* dyna;
/* 0x30 */ SSList* ssList;
} DynaRaycast; // size = 0x34
typedef struct
{
/* 0x00 */ StaticLookup* lookup;
/* 0x04 */ SSList* ssList;
/* 0x08 */ CollisionContext* colCtx;
/* 0x0C */ u16 xpFlags1;
/* 0x0E */ u16 xpFlags2;
/* 0x10 */ Vec3f* posA;
/* 0x14 */ Vec3f* posB;
/* 0x18 */ Vec3f* outPos;
/* 0x1C */ CollisionPoly** outPoly;
/* 0x20 */ f32 outDistSq;
/* 0x24 */ f32 checkDist;
/* 0x28 */ s32 bccFlags;
/* 0x2C */ Actor* actor;
} StaticLineTest; // size = 0x30
typedef struct {
/* 0x00 */ struct CollisionContext* colCtx;
/* 0x00 */ CollisionContext* colCtx;
/* 0x04 */ u16 xpFlags;
/* 0x08 */ DynaCollisionContext* dyna;
/* 0x0C */ SSList* ssList;
@ -195,9 +259,46 @@ typedef struct {
/* 0x14 */ Vec3f* posB;
/* 0x18 */ Vec3f* posResult;
/* 0x1C */ CollisionPoly** resultPoly;
/* 0x20 */ s32 chkOneFace; // bccFlags & 0x8
/* 0x24 */ f32* distSq; // distance from posA to poly squared
/* 0x28 */ f32 chkDist; // distance from poly
} DynaLineTest;
/* 0x20 */ s32 checkOneFace; // bccFlags & 0x8
/* 0x24 */ f32* distSq; // distance from posA to poly squared
/* 0x28 */ f32 checkDist; // distance from poly
/* 0x2C */ Actor* actor;
/* 0x30 */ s32 bgId;
} DynaLineTest; // size = 0x34
typedef struct {
/* 0x00 */ CollisionPoly* poly;
/* 0x04 */ Vec3s* vtxList;
/* 0x08 */ Vec3f* posA;
/* 0x0C */ Vec3f* posB;
/* 0x10 */ Vec3f* planeIntersect;
/* 0x14 */ s32 checkOneFace;
/* 0x18 */ f32 checkDist;
} BgLineVsPolyTest; // size = 0x1C
typedef struct {
/* 0x0 */ s16 sceneId;
/* 0x4 */ u32 memSize;
} BgSpecialSceneMaxMemory; // size = 0x8
typedef struct {
/* 0x0 */ s16 sceneId;
/* 0x2 */ s16 maxNodes;
/* 0x4 */ s16 maxPolygons;
/* 0x6 */ s16 maxVertices;
} BgSpecialSceneMaxObjects; // size = 0x8
typedef struct {
/* 0x0 */ s16 sceneId;
/* 0x2 */ s16 xSubdivisions;
/* 0x4 */ s16 ySubdivisions;
/* 0x6 */ s16 zSubdivisions;
/* 0x8 */ s32 unk8;
} BgSpecialSceneMeshSubdivision; // size = 0xC
typedef struct {
s16 sceneId;
Vec3s subdivAmount;
s32 nodeListMax; // if -1, dynamically compute max nodes
} BgCheckSceneSubdivisionEntry;
#endif

2
spec
View File

@ -451,8 +451,6 @@ beginseg
include "build/data/code/z_actor.bss.o"
include "build/src/code/z_actor_dlftbls.o"
include "build/src/code/z_bgcheck.o"
include "build/data/code/z_bgcheck.data.o"
include "build/data/code/z_bgcheck.bss.o"
include "build/src/code/z_bg_collect.o"
include "build/src/code/z_bg_item.o"
include "build/src/code/z_camera.o"

50
src/code/sys_math3d.c
View File

@ -2,7 +2,7 @@
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_Normalize.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_80179678.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_PlaneVsLineSegClosestPoint.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_80179798.s")
@ -46,7 +46,7 @@
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_Vec3fMagnitude.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_DistanceSquared.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_Vec3fDistSq.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_Distance.s")
@ -60,15 +60,15 @@
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_CrossProduct.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_NormalVector.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_SurfaceNorm.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017A954.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_PointRelativeToCubeFaces.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017AA0C.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_PointRelativeToCubeEdges.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017ABBC.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_PointRelativeToCubeVertices.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017AD38.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_LineVsCube.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017B68C.s")
@ -80,51 +80,51 @@
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017B9D8.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_NormalizedDistanceFromPlane.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_UDistPlaneToPos.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_NormalizedSignedDistanceFromPlane.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_DistPlaneToPos.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017BAD0.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_TriChkPointParaYDist.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017BD98.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017BDE0.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017BE30.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_TriChkPointParaYIntersectDist.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017BEE0.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_TriChkPointParaYIntersectInsideTri.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017BF8C.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017C008.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_TriChkLineSegParaYIntersect.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017C17C.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017C1F0.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017C494.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_TriChkPointParaYIntersectInsideTri2.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017C540.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_TriChkPointParaXDist.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017C808.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017C850.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_TriChkPointParaXIntersect.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017C904.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017C980.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_TriChkLineSegParaXIntersect.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017CB08.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017CB7C.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_TriChkLineSegParaZDist.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017CEA8.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017CEF0.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_TriChkPointParaZIntersect.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017CFA4.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017D020.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_TriChkLineSegParaZIntersect.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017D1AC.s")
@ -148,7 +148,7 @@
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017DA24.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_ColSphereLineSeg.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_LineVsSph.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017DD34.s")
@ -162,7 +162,7 @@
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017F1A0.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_ColSphereSphere.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_SphVsSph.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_ColSphereSphereIntersect.s")
@ -178,11 +178,11 @@
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3d_ColTriTri.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017F9C0.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_XZInSphere.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017FA34.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_XYInSphere.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017FAA8.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_YZInSphere.s")
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/func_8017FB1C.s")

48
src/code/z_bg_collect.c
View File

@ -1,33 +1,33 @@
#include "global.h"
void BgCheck2_UpdateActorPosition(CollisionContext* colCtx, s32 index, Actor* actor) {
void BgCheck2_UpdateActorPosition(CollisionContext* colCtx, s32 bgId, Actor* actor) {
MtxF prevMatrix;
MtxF prevMatrixInv;
MtxF currMatrix;
Vec3f newPos;
Vec3f posWithInv;
if (BgCheck_IsActorMeshIndexValid(index) == 0) {
if (!DynaPoly_IsBgIdBgActor(bgId)) {
return;
}
SkinMatrix_SetScaleRotateYRPTranslate(
&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);
&prevMatrix, colCtx->dyna.bgActors[bgId].prevTransform.scale.x,
colCtx->dyna.bgActors[bgId].prevTransform.scale.y, colCtx->dyna.bgActors[bgId].prevTransform.scale.z,
colCtx->dyna.bgActors[bgId].prevTransform.rot.x, colCtx->dyna.bgActors[bgId].prevTransform.rot.y,
colCtx->dyna.bgActors[bgId].prevTransform.rot.z, colCtx->dyna.bgActors[bgId].prevTransform.pos.x,
colCtx->dyna.bgActors[bgId].prevTransform.pos.y, colCtx->dyna.bgActors[bgId].prevTransform.pos.z);
if (SkinMatrix_Invert(&prevMatrix, &prevMatrixInv) == 2) {
return;
}
SkinMatrix_SetScaleRotateYRPTranslate(
&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);
&currMatrix, colCtx->dyna.bgActors[bgId].curTransform.scale.x, colCtx->dyna.bgActors[bgId].curTransform.scale.y,
colCtx->dyna.bgActors[bgId].curTransform.scale.z, colCtx->dyna.bgActors[bgId].curTransform.rot.x,
colCtx->dyna.bgActors[bgId].curTransform.rot.y, colCtx->dyna.bgActors[bgId].curTransform.rot.z,
colCtx->dyna.bgActors[bgId].curTransform.pos.x, colCtx->dyna.bgActors[bgId].curTransform.pos.y,
colCtx->dyna.bgActors[bgId].curTransform.pos.z);
SkinMatrix_Vec3fMtxFMultXYZ(&prevMatrixInv, &actor->world.pos, &posWithInv);
SkinMatrix_Vec3fMtxFMultXYZ(&currMatrix, &posWithInv, &newPos);
@ -35,14 +35,14 @@ void BgCheck2_UpdateActorPosition(CollisionContext* colCtx, s32 index, Actor* ac
actor->world.pos = newPos;
}
void BgCheck2_UpdateActorYRotation(CollisionContext* colCtx, s32 index, Actor* actor) {
void BgCheck2_UpdateActorYRotation(CollisionContext* colCtx, s32 bgId, Actor* actor) {
s16 angleChange;
if (BgCheck_IsActorMeshIndexValid(index) == 0) {
if (!DynaPoly_IsBgIdBgActor(bgId)) {
return;
}
angleChange = colCtx->dyna.bgActors[index].curTransform.rot.y - colCtx->dyna.bgActors[index].prevTransform.rot.y;
angleChange = colCtx->dyna.bgActors[bgId].curTransform.rot.y - colCtx->dyna.bgActors[bgId].prevTransform.rot.y;
if (actor->id == 0) {
((Player*)actor)->currentYaw += angleChange;
@ -52,14 +52,14 @@ void BgCheck2_UpdateActorYRotation(CollisionContext* colCtx, s32 index, Actor* a
actor->world.rot.y += angleChange;
}
void BgCheck2_AttachToMesh(CollisionContext* colCtx, Actor* actor, s32 index) {
void BgCheck2_AttachToMesh(CollisionContext* colCtx, Actor* actor, s32 bgId) {
DynaPolyActor* meshActor;
if (BgCheck_IsActorMeshIndexValid(index) == 0) {
if (!DynaPoly_IsBgIdBgActor(bgId)) {
return;
}
meshActor = BgCheck_GetActorOfMesh(colCtx, index);
meshActor = DynaPoly_GetActor(colCtx, bgId);
if (meshActor != NULL) {
DynaPolyActor_SetRidingFallingState(meshActor);
@ -72,31 +72,31 @@ void BgCheck2_AttachToMesh(CollisionContext* colCtx, Actor* actor, s32 index) {
}
}
u32 BgCheck2_UpdateActorAttachedToMesh(CollisionContext* colCtx, s32 index, Actor* actor) {
u32 BgCheck2_UpdateActorAttachedToMesh(CollisionContext* colCtx, s32 bgId, Actor* actor) {
u32 wasUpdated = 0;
DynaPolyActor* meshActor;
if (BgCheck_IsActorMeshIndexValid(index) == 0) {
if (!DynaPoly_IsBgIdBgActor(bgId)) {
return 0;
}
if (colCtx->dyna.bgActorFlags[index] & 2 || !(colCtx->dyna.bgActorFlags[index] & 1)) {
if (colCtx->dyna.bgActorFlags[bgId] & 2 || !(colCtx->dyna.bgActorFlags[bgId] & 1)) {
return 0;
}
meshActor = BgCheck_GetActorOfMesh(colCtx, index);
meshActor = DynaPoly_GetActor(colCtx, bgId);
if (meshActor == NULL) {
return 0;
}
if (meshActor->flags & 1) {
BgCheck2_UpdateActorPosition(colCtx, index, actor);
BgCheck2_UpdateActorPosition(colCtx, bgId, actor);
wasUpdated = 1;
}
if (meshActor->flags & 2) {
BgCheck2_UpdateActorYRotation(colCtx, index, actor);
BgCheck2_UpdateActorYRotation(colCtx, bgId, actor);
wasUpdated = 1;
}

20
src/code/z_bg_item.c
View File

@ -18,8 +18,8 @@ void DynaPolyActor_Init(DynaPolyActor* dynaActor, s32 flags) {
void DynaPolyActor_LoadMesh(GlobalContext* globalCtx, DynaPolyActor* dynaActor, CollisionHeader* meshHeader) {
CollisionHeader* header = NULL;
BgCheck_RelocateMeshHeader(meshHeader, &header);
dynaActor->bgId = BgCheck_AddActorMesh(globalCtx, &globalCtx->colCtx.dyna, dynaActor, header);
CollisionHeader_GetVirtual(meshHeader, &header);
dynaActor->bgId = DynaPoly_SetBgActor(globalCtx, &globalCtx->colCtx.dyna, &dynaActor->actor, header);
}
void DynaPolyActor_ResetState(DynaPolyActor* dynaActor) {
@ -34,8 +34,8 @@ void DynaPolyActor_SetRidingMovingState(DynaPolyActor* dynaActor) {
dynaActor->stateFlags |= DYNAPOLY_STATE_RIDING_MOVING;
}
void DynaPolyActor_SetRidingMovingStateByIndex(CollisionContext* colCtx, s32 index) {
DynaPolyActor* dynaActor = BgCheck_GetActorOfMesh(colCtx, index);
void DynaPolyActor_SetRidingMovingStateByIndex(CollisionContext* colCtx, s32 bgId) {
DynaPolyActor* dynaActor = DynaPoly_GetActor(colCtx, bgId);
if (dynaActor != NULL) {
DynaPolyActor_SetRidingMovingState(dynaActor);
@ -46,8 +46,8 @@ void DynaPolyActor_SetRidingRotatingState(DynaPolyActor* dynaActor) {
dynaActor->stateFlags |= DYNAPOLY_STATE_RIDING_ROTATING;
}
void DynaPolyActor_SetRidingRotatingStateByIndex(CollisionContext* colCtx, s32 index) {
DynaPolyActor* dynaActor = BgCheck_GetActorOfMesh(colCtx, index);
void DynaPolyActor_SetRidingRotatingStateByIndex(CollisionContext* colCtx, s32 bgId) {
DynaPolyActor* dynaActor = DynaPoly_GetActor(colCtx, bgId);
if (dynaActor != NULL) {
DynaPolyActor_SetRidingRotatingState(dynaActor);
@ -125,16 +125,16 @@ s32 DynaPolyActor_ValidateMove(GlobalContext* globalCtx, DynaPolyActor* dynaActo
endPos.y = startPos.y;
endPos.z = sign * adjustedEndRadius * cos + startPos.z;
if (func_800C56E0(&globalCtx->colCtx, &startPos, &endPos, &intersectionPos, &poly, true, false, false, true, &bgId,
&dynaActor->actor, 0.0f)) {
if (BgCheck_EntityLineTest3(&globalCtx->colCtx, &startPos, &endPos, &intersectionPos, &poly, true, false, false,
true, &bgId, &dynaActor->actor, 0.0f)) {
return false;
}
startPos.x = (dynaActor->actor.world.pos.x * 2.0f) - startPos.x;
startPos.z = (dynaActor->actor.world.pos.z * 2.0f) - startPos.z;
endPos.x = sign * adjustedEndRadius * sin + startPos.x;
endPos.z = sign * adjustedEndRadius * cos + startPos.z;
if (func_800C56E0(&globalCtx->colCtx, &startPos, &endPos, &intersectionPos, &poly, true, false, false, true, &bgId,
&dynaActor->actor, 0.0f)) {
if (BgCheck_EntityLineTest3(&globalCtx->colCtx, &startPos, &endPos, &intersectionPos, &poly, true, false, false,
true, &bgId, &dynaActor->actor, 0.0f)) {
return false;
}
return true;

5071
src/code/z_bgcheck.c
View File

File diff suppressed because it is too large Load Diff

6
src/code/z_collision_check.c
View File

@ -941,7 +941,7 @@ s32 Collider_QuadSetNearestAC(GlobalContext* globalCtx, ColliderQuad* quad, Vec3
return 1;
}
Math_Vec3s_ToVec3f(&dcMid, &quad->dim.dcMid);
acDist = Math3D_DistanceSquared(&dcMid, hitPos);
acDist = Math3D_Vec3fDistSq(&dcMid, hitPos);
if (acDist < quad->dim.acDist) {
quad->dim.acDist = acDist;
@ -3510,7 +3510,7 @@ s32 CollisionCheck_LineOC_JntSph(GlobalContext* globalCtx, CollisionCheckContext
D_801EDEB0.a = *a;
D_801EDEB0.b = *b;
if (Math3D_ColSphereLineSeg(&element->dim.worldSphere, &D_801EDEB0) != 0) {
if (Math3D_LineVsSph(&element->dim.worldSphere, &D_801EDEB0) != 0) {
return 1;
}
}
@ -3548,7 +3548,7 @@ s32 CollisionCheck_LineOC_Sphere(GlobalContext* globalCtx, CollisionCheckContext
D_801EDFC8.a = *a;
D_801EDFC8.b = *b;
if (Math3D_ColSphereLineSeg(&sphere->dim.worldSphere, &D_801EDFC8) != 0) {
if (Math3D_LineVsSph(&sphere->dim.worldSphere, &D_801EDFC8) != 0) {
return 1;
}

6
src/code/z_fireobj.c
View File

@ -94,7 +94,7 @@ void FireObj_StepSize(FireObj* fire) {
void FireObj_UpdateStateTransitions(GlobalContext* globalCtx, FireObj* fire) {
Player* player = GET_PLAYER(globalCtx);
WaterBox* waterBox;
f32 sp44;
f32 waterY;
s32 sp40 = 0;
u8 nextState;
Vec3f dist;
@ -113,8 +113,8 @@ void FireObj_UpdateStateTransitions(GlobalContext* globalCtx, FireObj* fire) {
FireObj_SetState(fire, fire->dynamicSizeStep, nextState);
}
if ((fire->flags & 1) && (fire->state != FIRE_STATE_3) &&
(func_800CA1E8(globalCtx, &globalCtx->colCtx, fire->position.x, fire->position.z, &sp44, &waterBox) != 0) &&
((fire->yScale * ((void)0, 6500.0f)) < (sp44 - fire->position.y))) { // Fake but IDK what else
WaterBox_GetSurface1_2(globalCtx, &globalCtx->colCtx, fire->position.x, fire->position.z, &waterY, &waterBox) &&
((fire->yScale * ((void)0, 6500.0f)) < (waterY - fire->position.y))) { // Fake but IDK what else
FireObj_SetState(fire, fire->dynamicSizeStep, FIRE_STATE_3);
}
if ((fire->flags & 2) && (player->itemActionParam == PLAYER_AP_STICK)) {

5
src/code/z_quake.c
View File

@ -416,8 +416,9 @@ void Quake2_ClearType(s32 type) {
}
s32 Quake2_GetFloorQuake(Player* player) {
if (func_800C9D8C(&sQuake2Context.globalCtx->colCtx, player->actor.floorPoly, player->actor.floorBgId) == 0) {
return func_800C9E18(&sQuake2Context.globalCtx->colCtx, player->actor.floorPoly, player->actor.floorBgId);
if (!SurfaceType_IsConveyor(&sQuake2Context.globalCtx->colCtx, player->actor.floorPoly, player->actor.floorBgId)) {
return SurfaceType_GetConveyorSpeed(&sQuake2Context.globalCtx->colCtx, player->actor.floorPoly,
player->actor.floorBgId);
}
return 0;
}

2
src/code/z_scene.c
View File

@ -204,7 +204,7 @@ void Scene_HeaderCmdColHeader(GlobalContext* globalCtx, SceneCmd* cmd) {
colHeader->waterBoxes = (WaterBox*)Lib_SegmentedToVirtual(colHeader->waterBoxes);
}
BgCheck_Init(&globalCtx->colCtx, globalCtx, colHeader);
BgCheck_Allocate(&globalCtx->colCtx, globalCtx, colHeader);
}
// SceneTableEntry Header Command 0x04: Room List

4
src/code/z_scene_proc.c
View File

@ -722,9 +722,9 @@ void Scene_DrawConfigGreatBayTemple(GlobalContext* globalCtx) {
if (Flags_GetSwitch(globalCtx, 0x33) && Flags_GetSwitch(globalCtx, 0x34) && Flags_GetSwitch(globalCtx, 0x35) &&
Flags_GetSwitch(globalCtx, 0x36)) {
func_800C3C00(&globalCtx->colCtx, 1);
BgCheck_SetContextFlags(&globalCtx->colCtx, BGCHECK_FLAG_REVERSE_CONVEYOR_FLOW);
} else {
func_800C3C14(&globalCtx->colCtx, 1);
BgCheck_UnsetContextFlags(&globalCtx->colCtx, BGCHECK_FLAG_REVERSE_CONVEYOR_FLOW);
}
dList = (Gfx*)GRAPH_ALLOC(globalCtx->state.gfxCtx, sizeof(Gfx) * 18);

7
src/code/z_snap.c
View File

@ -113,11 +113,11 @@ s32 func_8013A530(GlobalContext* globalCtx, Actor* actor, s32 flag, Vec3f* pos,
s16 x;
s16 y;
f32 distance;
CollisionPoly* unk1;
CollisionPoly* poly;
Camera* camera;
Actor* actors[2];
s32 ret = 0;
u32 unk2;
s32 bgId;
camera = GET_ACTIVE_CAM(globalCtx);
@ -142,7 +142,8 @@ s32 func_8013A530(GlobalContext* globalCtx, Actor* actor, s32 flag, Vec3f* pos,
ret |= 0x3d;
}
if (func_800C576C(&globalCtx->colCtx, pos, &camera->eye, &screenSpace, &unk1, 1, 1, 1, 1, &unk2) != 0) {
if (BgCheck_ProjectileLineTest(&globalCtx->colCtx, pos, &camera->eye, &screenSpace, &poly, true, true, true, true,
&bgId)) {
func_8013A41C(0x3c);
ret |= 0x3c;
}

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

@ -232,8 +232,8 @@ void ArmsHook_Shoot(ArmsHook* this, GlobalContext* globalCtx) {
}
} else {
CollisionPoly* poly;
u32 bgId;
Vec3f sp78;
s32 bgId;
Vec3f posResult;
Vec3f prevFrameDiff;
Vec3f sp60;
@ -244,20 +244,23 @@ void ArmsHook_Shoot(ArmsHook* this, GlobalContext* globalCtx) {
sp60.x = this->unk1EC.x - (this->unk1E0.x - this->unk1EC.x);
sp60.y = this->unk1EC.y - (this->unk1E0.y - this->unk1EC.y);
sp60.z = this->unk1EC.z - (this->unk1E0.z - this->unk1EC.z);
if (func_800C55C4(&globalCtx->colCtx, &sp60, &this->unk1E0, &sp78, &poly, 1, 1, 1, 1, &bgId) != 0 &&
(func_800B90AC(globalCtx, &this->actor, poly, bgId, &sp78) == 0 ||
func_800C576C(&globalCtx->colCtx, &sp60, &this->unk1E0, &sp78, &poly, 1, 1, 1, 1, &bgId) != 0)) {
f32 sp5C = poly->normal.x * (1 / SHT_MAX);
f32 sp58 = poly->normal.z * (1 / SHT_MAX);
if (BgCheck_EntityLineTest1(&globalCtx->colCtx, &sp60, &this->unk1E0, &posResult, &poly, true, true, true, true,
&bgId) &&
(func_800B90AC(globalCtx, &this->actor, poly, bgId, &posResult) == 0 ||
BgCheck_ProjectileLineTest(&globalCtx->colCtx, &sp60, &this->unk1E0, &posResult, &poly, true, true, true,
true, &bgId))) {
f32 nx = COLPOLY_GET_NORMAL(poly->normal.x);
f32 nz = COLPOLY_GET_NORMAL(poly->normal.z);
Math_Vec3f_Copy(&this->actor.world.pos, &sp78);
this->actor.world.pos.x += 10.0f * sp5C;
this->actor.world.pos.z += 10.0f * sp58;
Math_Vec3f_Copy(&this->actor.world.pos, &posResult);
this->actor.world.pos.x += 10.0f * nx;
this->actor.world.pos.z += 10.0f * nz;
this->timer = 1;
if (func_800C9CEC(&globalCtx->colCtx, poly, bgId)) {
if (SurfaceType_IsHookshotSurface(&globalCtx->colCtx, poly, bgId)) {
{
DynaPolyActor* dynaPolyActor;
if (bgId != 0x32 && (dynaPolyActor = BgCheck_GetActorOfMesh(&globalCtx->colCtx, bgId)) != NULL) {
if (bgId != BGCHECK_SCENE &&
(dynaPolyActor = DynaPoly_GetActor(&globalCtx->colCtx, bgId)) != NULL) {
ArmsHook_AttachHookToActor(this, &dynaPolyActor->actor);
}
}

2
src/overlays/actors/ovl_Bg_Ctower_Gear/z_bg_ctower_gear.c
View File

@ -158,7 +158,7 @@ void BgCtowerGear_Destroy(Actor* thisx, GlobalContext* globalCtx) {
type = BGCTOWERGEAR_GET_TYPE(this);
if ((type == WATER_WHEEL) || (type == ORGAN)) {
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
}
}

2
src/overlays/actors/ovl_Bg_Ctower_Rot/z_bg_ctower_rot.c
View File

@ -81,7 +81,7 @@ void BgCtowerRot_Init(Actor* thisx, GlobalContext* globalCtx) {
void BgCtowerRot_Destroy(Actor* thisx, GlobalContext* globalCtx) {
BgCtowerRot* this = THIS;
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
}
void BgCtowerRot_CorridorRotate(BgCtowerRot* this, GlobalContext* globalCtx) {

16
src/overlays/actors/ovl_Bg_Fu_Kaiten/z_bg_fu_kaiten.c
View File

@ -36,9 +36,9 @@ void BgFuKaiten_Init(Actor* thisx, GlobalContext* globalCtx) {
CollisionHeader* header = 0;
Actor_SetScale(thisx, 1.0);
DynaPolyActor_Init(&THIS->bg, 3);
BgCheck_RelocateMeshHeader(&D_06002D30, &header);
THIS->bg.bgId = BgCheck_AddActorMesh(globalCtx, &globalCtx->colCtx.dyna, &THIS->bg, header);
DynaPolyActor_Init(&THIS->dyna, 3);
CollisionHeader_GetVirtual(&D_06002D30, &header);
THIS->dyna.bgId = DynaPoly_SetBgActor(globalCtx, &globalCtx->colCtx.dyna, &THIS->dyna.actor, header);
THIS->bouceHeight = 0.0;
THIS->rotationSpeed = 0;
@ -47,23 +47,23 @@ void BgFuKaiten_Init(Actor* thisx, GlobalContext* globalCtx) {
}
void BgFuKaiten_Destroy(Actor* thisx, GlobalContext* globalCtx) {
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, THIS->bg.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, THIS->dyna.bgId);
}
void BgFuKaiten_UpdateRotation(BgFuKaiten* this) {
f32 f0;
this->bg.actor.shape.rot.y += this->rotationSpeed;
this->dyna.actor.shape.rot.y += this->rotationSpeed;
if (this->rotationSpeed > 0) {
f0 = this->rotationSpeed * .002f;
func_8019FAD8(&this->bg.actor.projectedPos, 8310, f0);
func_8019FAD8(&this->dyna.actor.projectedPos, 8310, f0);
}
}
void BgFuKaiten_UpdateHeight(BgFuKaiten* this) {
this->bounce += this->bounceSpeed;
this->bg.actor.world.pos.y = this->bg.actor.home.pos.y + this->elevation + this->bouceHeight;
this->dyna.actor.world.pos.y = this->dyna.actor.home.pos.y + this->elevation + this->bouceHeight;
this->bg.actor.world.pos.y -= this->bouceHeight * Math_CosS(this->bounce);
this->dyna.actor.world.pos.y -= this->bouceHeight * Math_CosS(this->bounce);
}
void BgFuKaiten_Update(Actor* thisx, GlobalContext* globalCtx) {

2
src/overlays/actors/ovl_Bg_Fu_Kaiten/z_bg_fu_kaiten.h
View File

@ -6,7 +6,7 @@
struct BgFuKaiten;
typedef struct BgFuKaiten {
/* 0x000 */ DynaPolyActor bg;
/* 0x000 */ DynaPolyActor dyna;
/* 0x15C */ UNK_TYPE1 pad15C[0x4];
/* 0x160 */ f32 elevation;
/* 0x164 */ f32 bouceHeight;

2
src/overlays/actors/ovl_Bg_Haka_Curtain/z_bg_haka_curtain.c
View File

@ -63,7 +63,7 @@ void BgHakaCurtain_Init(Actor* thisx, GlobalContext* globalCtx) {
void BgHakaCurtain_Destroy(Actor* thisx, GlobalContext* globalCtx) {
BgHakaCurtain* this = THIS;
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
}
void func_80B6DC98(BgHakaCurtain* this) {

2
src/overlays/actors/ovl_Bg_Haka_Tomb/z_bg_haka_tomb.c
View File

@ -56,7 +56,7 @@ void BgHakaTomb_Init(Actor* thisx, GlobalContext* globalCtx) {
void BgHakaTomb_Destroy(Actor* thisx, GlobalContext* globalCtx) {
BgHakaTomb* this = THIS;
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
}
void func_80BD6624(BgHakaTomb* this) {

4
src/overlays/actors/ovl_Bg_Hakugin_Post/z_bg_hakugin_post.c
View File

@ -523,7 +523,7 @@ void func_80A9C058(BgHakuginPost* this, GlobalContext* globalCtx, BgHakuginPostU
sp44.x = this->dyna.actor.home.pos.x + unkStruct1->unk_14.x;
sp44.y = this->unk_16C + unkStruct1->unk_14.y;
sp44.z = this->dyna.actor.home.pos.z + unkStruct1->unk_14.z;
func_8013ECE0(Math3D_DistanceSquared(&sp44, &GET_PLAYER(globalCtx)->actor.world.pos), 255, 20, 150);
func_8013ECE0(Math3D_Vec3fDistSq(&sp44, &GET_PLAYER(globalCtx)->actor.world.pos), 255, 20, 150);
quake = Quake_Add(GET_ACTIVE_CAM(globalCtx), 3);
Quake_SetSpeed(quake, 20000);
Quake_SetQuakeValues(quake, 7, 0, 0, 0);
@ -718,7 +718,7 @@ void BgHakuginPost_Destroy(Actor* thisx, GlobalContext* globalCtx) {
BgHakuginPost* this = THIS;
if (BGHAKUGINPOST_GET_7(&this->dyna.actor) == 7) {
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
func_80A9AE3C(this, globalCtx);
}
}

2
src/overlays/actors/ovl_Bg_Icicle/z_bg_icicle.c
View File

@ -94,7 +94,7 @@ void BgIcicle_Init(Actor* thisx, GlobalContext* globalCtx) {
void BgIcicle_Destroy(Actor* thisx, GlobalContext* globalCtx) {
BgIcicle* this = THIS;
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
Collider_DestroyCylinder(globalCtx, &this->collider);
}

2
src/overlays/actors/ovl_Bg_Ikana_Shutter/z_bg_ikana_shutter.c
View File

@ -87,7 +87,7 @@ void BgIkanaShutter_Init(Actor* thisx, GlobalContext* globalCtx) {
void BgIkanaShutter_Destroy(Actor* thisx, GlobalContext* globalCtx) {
BgIkanaShutter* this = THIS;
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
}
void func_80BD5828(BgIkanaShutter* this) {

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

@ -124,7 +124,7 @@ void BgIkninSusceil_Init(Actor* thisx, GlobalContext* globalCtx) {
void BgIkninSusceil_Destroy(Actor* thisx, GlobalContext* globalCtx) {
BgIkninSusceil* this = THIS;
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
}
void func_80C0AB14(BgIkninSusceil* this) {

10
src/overlays/actors/ovl_Bg_Iknv_Obj/z_bg_iknv_obj.c
View File

@ -75,8 +75,8 @@ void BgIknvObj_Init(Actor* thisx, GlobalContext* globalCtx) {
case IKNV_OBJ_RAISED_DOOR:
this->displayListPtr = D_06011880;
DynaPolyActor_Init(&this->dyna, 0);
BgCheck_RelocateMeshHeader(&D_060119D4, &colHeader);
this->dyna.bgId = BgCheck_AddActorMesh(globalCtx, &globalCtx->colCtx.dyna, &this->dyna, colHeader);
CollisionHeader_GetVirtual(&D_060119D4, &colHeader);
this->dyna.bgId = DynaPoly_SetBgActor(globalCtx, &globalCtx->colCtx.dyna, &this->dyna.actor, colHeader);
this->actionFunc = BgIknvObj_UpdateRaisedDoor;
this->dyna.actor.world.pos.y = this->dyna.actor.home.pos.y + 120.0f;
break;
@ -84,8 +84,8 @@ void BgIknvObj_Init(Actor* thisx, GlobalContext* globalCtx) {
this->displayListPtr = D_060129C8;
this->actionFunc = BgIknvObj_UpdateSakonDoor;
DynaPolyActor_Init(&this->dyna, 0);
BgCheck_RelocateMeshHeader(&D_06012CA4, &colHeader);
this->dyna.bgId = BgCheck_AddActorMesh(globalCtx, &globalCtx->colCtx.dyna, &this->dyna, colHeader);
CollisionHeader_GetVirtual(&D_06012CA4, &colHeader);
this->dyna.bgId = DynaPoly_SetBgActor(globalCtx, &globalCtx->colCtx.dyna, &this->dyna.actor, colHeader);
Collider_InitAndSetCylinder(globalCtx, &this->collider, &this->dyna.actor, &sCylinderInit);
Collider_UpdateCylinder(&this->dyna.actor, &this->collider);
this->dyna.actor.colChkInfo.mass = MASS_IMMOVABLE;
@ -108,7 +108,7 @@ void BgIknvObj_Destroy(Actor* thisx, GlobalContext* globalCtx) {
return;
}
}
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
}
s32 func_80BD7CEC(BgIknvObj* this) {

2
src/overlays/actors/ovl_Bg_Kin2_Fence/z_bg_kin2_fence.c
View File

@ -180,7 +180,7 @@ void BgKin2Fence_Init(Actor* thisx, GlobalContext* globalCtx) {
void BgKin2Fence_Destroy(Actor* thisx, GlobalContext* globalCtx) {
BgKin2Fence* this = THIS;
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
Collider_DestroyJntSph(globalCtx, &this->collider);
}

2
src/overlays/actors/ovl_Bg_Ladder/z_bg_ladder.c
View File

@ -94,7 +94,7 @@ void BgLadder_Init(Actor* thisx, GlobalContext* globalCtx) {
void BgLadder_Destroy(Actor* thisx, GlobalContext* globalCtx) {
BgLadder* this = THIS;
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
}
void BgLadder_ActionWait(BgLadder* this, GlobalContext* globalCtx) {

2
src/overlays/actors/ovl_Bg_Lbfshot/z_bg_lbfshot.c
View File

@ -44,7 +44,7 @@ void BgLbfshot_Init(Actor* thisx, GlobalContext* globalCtx) {
void BgLbfshot_Destroy(Actor* thisx, GlobalContext* globalCtx) {
BgLbfshot* this = THIS;
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
}
void BgLbfshot_Draw(Actor* thisx, GlobalContext* globalCtx) {
func_800BDFC0(globalCtx, D_06000228);

12
src/overlays/actors/ovl_Bg_Lotus/z_bg_lotus.c
View File

@ -41,13 +41,13 @@ extern Gfx D_06000040[]; // Lilypad model
void BgLotus_Init(Actor* thisx, GlobalContext* globalCtx) {
BgLotus* this = THIS;
s32 pad;
s32 sp2C;
s32 bgId;
Actor_ProcessInitChain(&this->dyna.actor, sInitChain);
DynaPolyActor_Init(&this->dyna, 1);
DynaPolyActor_LoadMesh(globalCtx, &this->dyna, &D_06000A20);
this->dyna.actor.floorHeight =
func_800C411C(&globalCtx->colCtx, &thisx->floorPoly, &sp2C, &this->dyna.actor, &this->dyna.actor.world.pos);
this->dyna.actor.floorHeight = BgCheck_EntityRaycastFloor5(&globalCtx->colCtx, &thisx->floorPoly, &bgId,
&this->dyna.actor, &this->dyna.actor.world.pos);
this->timer2 = 96;
this->dyna.actor.world.rot.y = Rand_Next() >> 0x10;
this->actionFunc = BgLotus_Wait;
@ -56,7 +56,7 @@ void BgLotus_Init(Actor* thisx, GlobalContext* globalCtx) {
void BgLotus_Destroy(Actor* thisx, GlobalContext* globalCtx) {
BgLotus* this = THIS;
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
}
void BgLotus_SetScaleXZ(BgLotus* this) {
@ -167,8 +167,8 @@ void BgLotus_Update(Actor* thisx, GlobalContext* globalCtx) {
s32 pad;
WaterBox* waterBox;
func_800CA1E8(globalCtx, &globalCtx->colCtx, this->dyna.actor.world.pos.x, this->dyna.actor.world.pos.z,
&this->height, &waterBox);
WaterBox_GetSurface1_2(globalCtx, &globalCtx->colCtx, this->dyna.actor.world.pos.x, this->dyna.actor.world.pos.z,
&this->height, &waterBox);
this->actionFunc(this, globalCtx);
}

2
src/overlays/actors/ovl_Bg_Mbar_Chair/z_bg_mbar_chair.c
View File

@ -48,7 +48,7 @@ void BgMbarChair_Init(Actor* thisx, GlobalContext* globalCtx) {
void BgMbarChair_Destroy(Actor* thisx, GlobalContext* globalCtx) {
BgMbarChair* this = THIS;
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
}
void BgMbarChair_Update(Actor* thisx, GlobalContext* globalCtx) {

5
src/overlays/actors/ovl_Bg_Tobira01/z_bg_tobira01.c
View File

@ -47,7 +47,8 @@ void BgTobira01_Open(BgTobira01* this, GlobalContext* globalCtx) {
}
} else if (!(gSaveContext.weekEventReg[88] & 0x40) && (this->timer == 0) && (globalCtx->actorCtx.unk1F5 != 0) &&
(globalCtx->actorCtx.unk1F4 == 0) &&
(func_800C99AC(&globalCtx->colCtx, player->actor.floorPoly, player->actor.floorBgId) == 6)) {
(SurfaceType_GetSceneExitIndex(&globalCtx->colCtx, player->actor.floorPoly, player->actor.floorBgId) ==
6)) {
this->playCutscene = true;
this->unk_16C = 0; // this variable is not used anywhere else
}
@ -91,7 +92,7 @@ void BgTobira01_Destroy(Actor* thisx, GlobalContext* globalCtx) {
BgTobira01* this = THIS;
s32 pad;
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
}
void BgTobira01_Update(Actor* thisx, GlobalContext* globalCtx) {

9
src/overlays/actors/ovl_Boss_02/z_boss_02.c
View File

@ -752,7 +752,7 @@ void func_809DAB78(Boss02* this, GlobalContext* globalCtx) {
spD0.y = 2000.0f;
}
temp_f0 = func_800C3FA0(&globalCtx->colCtx, &spDC, &spD0);
temp_f0 = BgCheck_EntityRaycastFloor1(&globalCtx->colCtx, &spDC, &spD0);
if (((this->unk_017C.y < temp_f0) && (temp_f0 <= this->unk_0188.y)) ||
((temp_f0 < this->unk_017C.y) && (this->unk_0188.y <= temp_f0))) {
this->unk_0170 = this->unk_017C;
@ -1057,8 +1057,8 @@ void func_809DAB78(Boss02* this, GlobalContext* globalCtx) {
spD0.x = this->unk_0170.x + sp90.x;
spD0.y = this->unk_0170.y + (1000.0f * D_809DF5B0);
spD0.z = this->unk_0170.z + sp90.z;
if (func_800C40B4(&globalCtx->colCtx, &sp8C, &sp88, &spD0) != BGCHECK_Y_MIN) {
spA0 = func_800C3FA0(&globalCtx->colCtx, &sp8C, &spD0);
if (BgCheck_EntityRaycastFloor3(&globalCtx->colCtx, &sp8C, &sp88, &spD0) != BGCHECK_Y_MIN) {
spA0 = BgCheck_EntityRaycastFloor1(&globalCtx->colCtx, &sp8C, &spD0);
Matrix_GetStateTranslationAndScaledZ(5.0f * D_809DF5B0, &sp70);
sp70.y = 2.0f * D_809DF5B0;
sp64.y = 0.3f * D_809DF5B0;
@ -1183,7 +1183,8 @@ void func_809DC218(Actor* thisx, GlobalContext* globalCtx) {
sp24.y = 2000.0f;
}
if ((this->actor.focus.pos.y < func_800C3FA0(&globalCtx->colCtx, &sp20, &sp24)) || (D_809E0422 != 0)) {
if ((this->actor.focus.pos.y < BgCheck_EntityRaycastFloor1(&globalCtx->colCtx, &sp20, &sp24)) ||
(D_809E0422 != 0)) {
this->actor.flags &= ~1;
} else {
this->actor.flags |= 1;

2
src/overlays/actors/ovl_Dm_Char07/z_dm_char07.c
View File

@ -73,7 +73,7 @@ void DmChar07_Destroy(Actor* thisx, GlobalContext* globalCtx) {
DmChar07* this = THIS;
if (this->isStage) {
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
}
}

6
src/overlays/actors/ovl_En_Clear_Tag/z_en_clear_tag.c
View File

@ -642,7 +642,7 @@ void EnClearTag_UpdateEffects(EnClearTag* this, GlobalContext* globalCtx) {
sphereCenter.y += 5.0f;
// Check if the debris has hit the ground.
if (func_800C5A20(&globalCtx->colCtx, &sphereCenter, 11.0f)) {
if (BgCheck_SphVsFirstPoly(&globalCtx->colCtx, &sphereCenter, 11.0f)) {
effect->position.y = originalYPosition;
// Bounce the debris effect.
@ -976,8 +976,8 @@ void EnClearTag_DrawEffects(Actor* thisx, GlobalContext* globalCtx) {
* `ySurface` returns the water box's surface, while `outWaterBox` returns a pointer to the WaterBox
*/
ySurface = effect->position.y;
if (func_800CA1AC(globalCtx, &globalCtx->colCtx, effect->position.x + vec.x, effect->position.z + vec.z,
&ySurface, &waterBox)) {
if (WaterBox_GetSurface1(globalCtx, &globalCtx->colCtx, effect->position.x + vec.x,
effect->position.z + vec.z, &ySurface, &waterBox)) {
if ((effect->position.y - ySurface) < 200.0f) {
// Draw the splash effect.
Matrix_InsertTranslation(effect->position.x + vec.x, ySurface, effect->position.z + vec.z,

20
src/overlays/actors/ovl_En_Dg/z_en_dg.c
View File

@ -946,19 +946,19 @@ void func_8098B464(EnDg* this, GlobalContext* globalCtx) {
void func_8098B560(EnDg* this, GlobalContext* globalCtx) {
Vec3f sp54;
Vec3f sp48;
Vec3f pos;
s16 sp46 = 0;
WaterBox* sp40;
f32 sp3C;
s32 sp38;
WaterBox* waterBox;
f32 waterSurface;
CollisionPoly* poly;
f32 sp34;
sp54.x = this->actor.world.pos.x;
sp54.y = this->actor.world.pos.y + this->actor.depthInWater;
sp54.z = this->actor.world.pos.z + 20.0f;
sp48.x = (Math_SinS(this->actor.world.rot.y) * 50.0f) + this->actor.world.pos.x;
sp48.y = this->actor.home.pos.y + 100.0f;
sp48.z = (Math_CosS(this->actor.world.rot.y) * 50.0f) + this->actor.world.pos.z;
pos.x = (Math_SinS(this->actor.world.rot.y) * 50.0f) + this->actor.world.pos.x;
pos.y = this->actor.home.pos.y + 100.0f;
pos.z = (Math_CosS(this->actor.world.rot.y) * 50.0f) + this->actor.world.pos.z;
if (DECR(this->unk_284) == 0) {
if (!(this->unk_280 & 4)) {
@ -975,9 +975,9 @@ void func_8098B560(EnDg* this, GlobalContext* globalCtx) {
this->actor.velocity.y = -0.5f;
}
sp34 = func_800C4000(globalCtx, &globalCtx->colCtx, &sp38, &sp48);
sp34 = BgCheck_EntityRaycastFloor2(globalCtx, &globalCtx->colCtx, &poly, &pos);
if (this->actor.bgCheckFlags & 8) {
if (!func_800CA1AC(globalCtx, &globalCtx->colCtx, sp48.x, sp48.z, &sp3C, &sp40)) {
if (!WaterBox_GetSurface1(globalCtx, &globalCtx->colCtx, pos.x, pos.z, &waterSurface, &waterBox)) {
if (sp34 > -100.0f) {
this->unk_280 &= ~4;
this->actionFunc = func_8098B88C;
@ -985,7 +985,7 @@ void func_8098B560(EnDg* this, GlobalContext* globalCtx) {
sp46 = this->actor.wallYaw;
}
} else if (sp34 > -100.0f) {
if (sp3C < sp34) {
if (waterSurface < sp34) {
this->unk_280 &= ~4;
this->actionFunc = func_8098B88C;
} else {

2
src/overlays/actors/ovl_En_Dnb/z_en_dnb.c
View File

@ -122,7 +122,7 @@ void EnDnb_Init(Actor* thisx, GlobalContext* globalCtx) {
void EnDnb_Destroy(Actor* thisx, GlobalContext* globalCtx) {
EnDnb* this = THIS;
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
}
void EnDnb_Update(Actor* thisx, GlobalContext* globalCtx) {

2
src/overlays/actors/ovl_En_Dns/z_en_dns.c
View File

@ -267,7 +267,7 @@ s32 func_8092CC68(GlobalContext* globalCtx) {
if (!func_801690CC(globalCtx) && (player->actor.bgCheckFlags & 1) && (player->transformation != PLAYER_FORM_DEKU)) {
bgId = player->actor.floorBgId;
if (func_800C99AC(&globalCtx->colCtx, player->actor.floorPoly, bgId) != 4) {
if (SurfaceType_GetSceneExitIndex(&globalCtx->colCtx, player->actor.floorPoly, bgId) != 4) {
ret = true;
}
}

2
src/overlays/actors/ovl_En_Dodongo/z_en_dodongo.c
View File

@ -366,7 +366,7 @@ void func_80876930(EnDodongo* this, GlobalContext* globalCtx, Vec3f* arg2) {
s16 temp2;
f32 temp3;
if (func_800C9BB8(&globalCtx->colCtx, this->actor.floorPoly, this->actor.floorBgId) == 14) {
if (func_800C9BB8(&globalCtx->colCtx, this->actor.floorPoly, this->actor.floorBgId) == COLPOLY_SURFACE_SNOW) {
sp80 = &D_8087932C;
sp7C = &D_80879330;
} else {

6
src/overlays/actors/ovl_En_Encount2/z_en_encount2.c
View File

@ -107,8 +107,8 @@ void EnEncount2_Init(Actor* thisx, GlobalContext* globalCtx) {
CollisionHeader* colHeader = NULL;
DynaPolyActor_Init(&this->dyna, 0);
BgCheck_RelocateMeshHeader(&D_06002420, &colHeader);
this->dyna.bgId = BgCheck_AddActorMesh(globalCtx, &globalCtx->colCtx.dyna, &this->dyna, colHeader);
CollisionHeader_GetVirtual(&D_06002420, &colHeader);
this->dyna.bgId = DynaPoly_SetBgActor(globalCtx, &globalCtx->colCtx.dyna, &this->dyna.actor, colHeader);
ActorShape_Init(&this->dyna.actor.shape, 0.0f, func_800B3FC0, 25.0f);
this->dyna.actor.colChkInfo.mass = MASS_IMMOVABLE;
Collider_InitAndSetJntSph(globalCtx, &this->collider, &this->dyna.actor, &sJntSphInit, &this->colElement);
@ -139,7 +139,7 @@ void EnEncount2_Init(Actor* thisx, GlobalContext* globalCtx) {
void EnEncount2_Destroy(Actor* thisx, GlobalContext* globalCtx) {
EnEncount2* this = THIS;
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
Collider_DestroyJntSph(globalCtx, &this->collider);
}

25
src/overlays/actors/ovl_En_Fish2/z_en_fish2.c
View File

@ -268,7 +268,7 @@ s32 func_80B288E8(EnFish2* this, Vec3f vec, s32 arg2) {
}
s32 func_80B2899C(EnFish2* this, GlobalContext* globalCtx) {
if (func_800C5A64(&globalCtx->colCtx, &this->unk_2F4, this->unk_33C)) {
if (BgCheck_SphVsFirstWall(&globalCtx->colCtx, &this->unk_2F4, this->unk_33C)) {
return true;
}
@ -294,8 +294,8 @@ void func_80B289DC(EnFish2* this, GlobalContext* globalCtx) {
this->actor.velocity.y = 0.0f;
this->actor.gravity = 0.0f;
}
} else if (func_800CA1AC(globalCtx, &globalCtx->colCtx, this->actor.world.pos.x, this->actor.world.pos.z,
&this->unk_334, &sp2C)) {
} else if (WaterBox_GetSurface1(globalCtx, &globalCtx->colCtx, this->actor.world.pos.x, this->actor.world.pos.z,
&this->unk_334, &sp2C)) {
if ((this->unk_334 != BGCHECK_Y_MIN) && (this->actor.world.pos.y < (this->unk_334 - this->unk_2D8))) {
this->actor.velocity.y = this->actor.world.rot.x * 0.001f * -0.1f;
if (this->actionFunc == func_80B297FC) {
@ -373,8 +373,9 @@ void func_80B28C14(EnFish2* this, GlobalContext* globalCtx) {
}
}
if ((this->unk_334 == BGCHECK_Y_MIN) && !func_800CA1AC(globalCtx, &globalCtx->colCtx, this->actor.world.pos.x,
this->actor.world.pos.z, &this->unk_334, &waterbox)) {
if ((this->unk_334 == BGCHECK_Y_MIN) &&
!WaterBox_GetSurface1(globalCtx, &globalCtx->colCtx, this->actor.world.pos.x, this->actor.world.pos.z,
&this->unk_334, &waterbox)) {
this->unk_334 = this->actor.world.pos.y;
}
@ -906,8 +907,8 @@ void func_80B2A498(EnFish2* this, GlobalContext* globalCtx) {
(Animation_OnFrame(&this->skelAnime, 13.0f) || Animation_OnFrame(&this->skelAnime, 31.0f))) {
WaterBox* sp78;
if (func_800CA1AC(globalCtx, &globalCtx->colCtx, this->actor.world.pos.x, this->actor.world.pos.z,
&this->unk_334, &sp78)) {
if (WaterBox_GetSurface1(globalCtx, &globalCtx->colCtx, this->actor.world.pos.x, this->actor.world.pos.z,
&this->unk_334, &sp78)) {
Vec3f sp6C;
s32 i;
@ -999,8 +1000,8 @@ void EnFish2_Update(Actor* thisx, GlobalContext* globalCtx2) {
this->actor.world.pos.y = this->unk_2D4 + 0.1f;
}
if (func_800CA1AC(globalCtx, &globalCtx->colCtx, this->actor.world.pos.x, this->actor.world.pos.z,
&this->unk_334, &sp6C)) {
if (WaterBox_GetSurface1(globalCtx, &globalCtx->colCtx, this->actor.world.pos.x, this->actor.world.pos.z,
&this->unk_334, &sp6C)) {
if ((this->unk_334 != BGCHECK_Y_MIN) && (this->unk_334 - this->unk_2D8 < this->actor.world.pos.y)) {
this->actor.world.pos.y = this->unk_334 - this->unk_2D8;
}
@ -1012,8 +1013,8 @@ void EnFish2_Update(Actor* thisx, GlobalContext* globalCtx2) {
f32 phi_f20 = 0;
WaterBox* sp4C;
if (func_800CA1AC(globalCtx, &globalCtx->colCtx, this->actor.world.pos.x, this->actor.world.pos.z,
&this->unk_334, &sp4C)) {
if (WaterBox_GetSurface1(globalCtx, &globalCtx->colCtx, this->actor.world.pos.x,
this->actor.world.pos.z, &this->unk_334, &sp4C)) {
phi_f20 = D_80B2B3A8[temp_s0_2] + (this->unk_334 - this->unk_2D8);
phi_f2 = D_80B2B3A8[temp_s0_2 + 1] + this->unk_2D4;
}
@ -1136,7 +1137,7 @@ void func_80B2AF80(EnFish2* this, GlobalContext* globalCtx) {
ptr->unk_04.y += 1.0f + ((Rand_ZeroOne() - 0.3f) * 1.2f);
ptr->unk_04.z += (0.3f + (Rand_ZeroOne() * 0.5f)) - 0.55f;
sp8C = ptr->unk_04.y;
if (!func_800CA1AC(globalCtx, &globalCtx->colCtx, ptr->unk_04.x, ptr->unk_04.z, &sp8C, &sp90)) {
if (!WaterBox_GetSurface1(globalCtx, &globalCtx->colCtx, ptr->unk_04.x, ptr->unk_04.z, &sp8C, &sp90)) {
ptr->unk_00 = 0;
} else if (sp8C < ptr->unk_04.y) {
Vec3f sp7C;

2
src/overlays/actors/ovl_En_Fu/z_en_fu.c
View File

@ -264,7 +264,7 @@ void func_80961D7C(GlobalContext* globalCtx) {
EnBom* bomb = (EnBom*)explosive;
if (bomb->actor.floorBgId != BGCHECK_SCENE) {
DynaPolyActor* fuKago = BgCheck_GetActorOfMesh(&globalCtx->colCtx, bomb->actor.floorBgId);
DynaPolyActor* fuKago = DynaPoly_GetActor(&globalCtx->colCtx, bomb->actor.floorBgId);
if ((fuKago != NULL) && (fuKago->actor.id == ACTOR_EN_FU_KAGO)) {
Math_SmoothStepToF(&bomb->actor.world.pos.x, fuKago->actor.world.pos.x, 0.1f, 1.0f, 0.5f);

21
src/overlays/actors/ovl_En_Goroiwa/z_en_goroiwa.c
View File

@ -472,17 +472,18 @@ s32 func_8093F6F8(EnGoroiwa* this, GlobalContext* globalCtx) {
this->unk_1C4 = 0.0f;
if (!(this->unk_1E5 & 0x20)) {
CollisionPoly* sp6C;
CollisionPoly* poly;
Vec3f sp60;
s32 pad[2];
s32 sp54;
s32 bgId;
Vec3f sp48;
sp60.x = this->actor.world.pos.x;
sp60.y = this->actor.world.pos.y + 50.0f;
sp60.z = this->actor.world.pos.z;
temp_f14 = func_800C4188(globalCtx, &globalCtx->colCtx, &sp6C, &sp54, &this->actor, &sp60);
temp_f14 =
BgCheck_EntityRaycastFloor5_2(globalCtx, &globalCtx->colCtx, &poly, &bgId, &this->actor, &sp60);
temp_f2 = temp_f14 - this->actor.world.pos.y;
if (fabsf(temp_f2) < (fabsf(this->actor.velocity.y) + 0.01f)) {
@ -513,8 +514,8 @@ s32 func_8093F6F8(EnGoroiwa* this, GlobalContext* globalCtx) {
WaterBox* sp44;
f32 sp40;
if (func_800CA1E8(globalCtx, &globalCtx->colCtx, this->actor.world.pos.x, this->actor.world.pos.z, &sp40,
&sp44)) {
if (WaterBox_GetSurface1_2(globalCtx, &globalCtx->colCtx, this->actor.world.pos.x, this->actor.world.pos.z,
&sp40, &sp44)) {
if ((this->actor.world.pos.y + this->unk_1DC) <= sp40) {
this->unk_1E5 |= 0x20;
if (sp40 < (this->unk_1DC + sp78)) {
@ -1367,7 +1368,7 @@ void func_8094220C(EnGoroiwa* this, GlobalContext* globalCtx) {
spC4.y = ptr->unk_00.y + 25.0f;
spC4.z = ptr->unk_00.z;
ptr->unk_18 = func_800C411C(&globalCtx->colCtx, &ptr->unk_28, &spD0, &this->actor, &spC4);
ptr->unk_18 = BgCheck_EntityRaycastFloor5(&globalCtx->colCtx, &ptr->unk_28, &spD0, &this->actor, &spC4);
if (ptr->unk_10 <= 0.0f) {
Matrix_InsertRotation(ptr->unk_1C, ptr->unk_1E, ptr->unk_20, 0);
@ -1449,7 +1450,7 @@ void EnGoroiwa_Update(Actor* thisx, GlobalContext* globalCtx) {
s32 pad;
EnGoroiwa* this = THIS;
Player* player = GET_PLAYER(globalCtx);
s32 sp60;
s32 bgId;
s32 sp5C = false;
Vec3f sp50;
f32 sp4C;
@ -1511,10 +1512,10 @@ void EnGoroiwa_Update(Actor* thisx, GlobalContext* globalCtx) {
sp50.x = this->actor.world.pos.x;
sp50.y = this->actor.world.pos.y + 50.0f;
sp50.z = this->actor.world.pos.z;
this->actor.floorHeight =
func_800C411C(&globalCtx->colCtx, &this->actor.floorPoly, &sp60, &this->actor, &sp50);
this->actor.floorHeight = BgCheck_EntityRaycastFloor5(&globalCtx->colCtx, &this->actor.floorPoly,
&bgId, &this->actor, &sp50);
if (this->actor.floorHeight > BGCHECK_Y_MIN) {
this->actor.floorBgId = sp60;
this->actor.floorBgId = bgId;
if (this->actor.world.pos.y <= (this->actor.floorHeight + 2.0f)) {
this->actor.bgCheckFlags |= 1;
} else {

14
src/overlays/actors/ovl_En_Invadepoh/z_en_invadepoh.c
View File

@ -3,7 +3,7 @@
* Overlay: ovl_En_Invadepoh
* Description: Ranch nighttime actors
*/
#include "prevent_bss_reordering.h"
#include "z_en_invadepoh.h"
#include "overlays/actors/ovl_En_Door/z_en_door.h"
@ -906,7 +906,7 @@ s32 func_80B44234(EnInvadepoh* this, Vec3f* vec) {
for (i = 0, arr = this->pathPoints; i < temp_s3; i++, arr++) {
Math_Vec3s_ToVec3f(&sp48, arr);
distance = Math3D_DistanceSquared(&sp48, vec);
distance = Math3D_Vec3fDistSq(&sp48, vec);
if (distance < min) {
min = distance;
ret = i;
@ -1384,7 +1384,7 @@ s32 func_80B45550(EnInvadepoh* this, GlobalContext* globalCtx, f32 range, s32 ar
while (actorIterator != NULL) {
if ((actorIterator->id == ACTOR_EN_DOOR) && (actorIterator->update != NULL) &&
(actorIterator->room == this->actor.room) &&
Math3D_DistanceSquared(&actorIterator->world.pos, &this->actor.world.pos) < range) {
Math3D_Vec3fDistSq(&actorIterator->world.pos, &this->actor.world.pos) < range) {
((EnDoor*)actorIterator)->unk_1A7 = arg3;
retVal = true;
break;
@ -1435,7 +1435,7 @@ void func_80B457A0(EnInvadepoh* this) {
for (i = 0; i < this->unk379; i++) {
if ((D_80B50320[i] != NULL) && D_80B50320[i]->drawAlien) {
distanceSquared = Math3D_DistanceSquared(&D_80B50320[i]->actor.world.pos, &this->actor.world.pos);
distanceSquared = Math3D_Vec3fDistSq(&D_80B50320[i]->actor.world.pos, &this->actor.world.pos);
if (distanceSquared < phi_f20) {
phi_f20 = distanceSquared;
phi_s5 = i;
@ -2880,7 +2880,7 @@ void func_80B49454(EnInvadepoh* this, GlobalContext* globalCtx) {
}
Math_Vec3f_Sum(&D_80B4EDD0[this->unk3AC], &this->actor.home.pos, &sp30);
if (Math3D_DistanceSquared(&this->actor.world.pos, &sp30) < SQ(400.0f)) {
if (Math3D_Vec3fDistSq(&this->actor.world.pos, &sp30) < SQ(400.0f)) {
this->actor.speedXZ *= 0.8f;
} else {
Math_StepToF(&this->actor.speedXZ, 170.0f, 21.0f);
@ -3614,7 +3614,7 @@ void func_80B4B564(EnInvadepoh* this, GlobalContext* globalCtx) {
if (this->unk3BC >= 0) {
Math_Vec3s_ToVec3f(&sp28, &this->pathPoints[this->unk3BC]);
temp_f0 = Math3D_DistanceSquared(&this->actor.world.pos, &sp28);
temp_f0 = Math3D_Vec3fDistSq(&this->actor.world.pos, &sp28);
if (temp_f0 < SQ(80.0f)) {
this->actor.speedXZ *= 0.85f;
} else if (temp_f0 < SQ(150.0f)) {
@ -3808,7 +3808,7 @@ void func_80B4BC4C(EnInvadepoh* this, GlobalContext* globalCtx) {
func_800B4AEC(globalCtx, &this->actor, 50.0f);
func_80B4516C(this);
Math_StepToS(&this->behaviorInfo.unk4C, 0xBB8, 0x1F5);
if (Math3D_DistanceSquared(&this->actor.prevPos, &this->actor.world.pos) > SQ(0.01f)) {
if (Math3D_Vec3fDistSq(&this->actor.prevPos, &this->actor.world.pos) > SQ(0.01f)) {
Math_SmoothStepToS(&this->actor.shape.rot.y, Math_Vec3f_Yaw(&this->actor.prevPos, &this->actor.world.pos),
3, this->behaviorInfo.unk4C, 0x1F4);
}

2
src/overlays/actors/ovl_En_Mm/z_en_mm.c
View File

@ -148,7 +148,7 @@ void func_80965DB4(EnMm* this, GlobalContext* globalCtx) {
temp_f2 = sqrtf(SQ(temp_f14) + SQ(temp_f12));
if ((temp_f2 < this->actor.speedXZ) ||
(func_800C9C74(&globalCtx->colCtx, this->actor.floorPoly, this->actor.floorBgId) == 1)) {
(SurfaceType_GetSlope(&globalCtx->colCtx, this->actor.floorPoly, this->actor.floorBgId) == 1)) {
this->actor.speedXZ = CLAMP_MAX(temp_f2, 16.0f);
this->actor.world.rot.y = Math_FAtan2F(temp_f12, temp_f14);
}

102
src/overlays/actors/ovl_En_Mushi2/z_en_mushi2.c
View File

@ -125,7 +125,7 @@ s32 func_80A68860(EnMushi2* this, GlobalContext* globalCtx) {
s32 pad;
s32 sp40;
CollisionPoly* sp3C;
f32 temp_f0 = func_800C411C(&globalCtx->colCtx, &sp3C, &sp40, &this->actor, &this->actor.world.pos);
f32 temp_f0 = BgCheck_EntityRaycastFloor5(&globalCtx->colCtx, &sp3C, &sp40, &this->actor, &this->actor.world.pos);
WaterBox* sp34;
f32 sp30;
@ -133,7 +133,8 @@ s32 func_80A68860(EnMushi2* this, GlobalContext* globalCtx) {
return true;
}
return func_800CA1E8(globalCtx, &globalCtx->colCtx, this->actor.world.pos.x, this->actor.world.pos.z, &sp30, &sp34);
return WaterBox_GetSurface1_2(globalCtx, &globalCtx->colCtx, this->actor.world.pos.x, this->actor.world.pos.z,
&sp30, &sp34);
}
s32 func_80A68910(EnMushi2* this, GlobalContext* globalCtx) {
@ -446,7 +447,7 @@ void func_80A69424(EnMushi2* this, GlobalContext* globalCtx) {
s32 func_80A69468(EnMushi2* this, GlobalContext* globalCtx) {
s32 pad;
Vec3f sp68;
Vec3f sp5C;
Vec3f posB;
Vec3f sp50;
f32 x;
f32 y;
@ -462,12 +463,12 @@ s32 func_80A69468(EnMushi2* this, GlobalContext* globalCtx) {
y = (this->unk_328.y * 4.0f);
z = (this->unk_328.z * 4.0f);
sp5C.x = (x + sp50.x) + this->actor.world.pos.x;
sp5C.y = (y + sp50.y) + this->actor.world.pos.y;
sp5C.z = (z + sp50.z) + this->actor.world.pos.z;
posB.x = (x + sp50.x) + this->actor.world.pos.x;
posB.y = (y + sp50.y) + this->actor.world.pos.y;
posB.z = (z + sp50.z) + this->actor.world.pos.z;
if (func_800C55C4(&globalCtx->colCtx, &this->actor.prevPos, &sp5C, &this->unk_33C, &this->unk_334, 1, 1, 1, 1,
&this->unk_338)) {
if (BgCheck_EntityLineTest1(&globalCtx->colCtx, &this->actor.prevPos, &posB, &this->unk_33C, &this->poly, true,
true, true, true, &this->polyBgId)) {
this->unk_30C |= 6;
return true;
}
@ -476,18 +477,19 @@ s32 func_80A69468(EnMushi2* this, GlobalContext* globalCtx) {
s32 func_80A6958C(EnMushi2* this, GlobalContext* globalCtx) {
s32 pad;
Vec3f sp48;
Vec3f sp3C;
Vec3f posA;
Vec3f posB;
sp48.x = (2.0f * this->unk_31C.x) + this->actor.world.pos.x;
sp48.y = (2.0f * this->unk_31C.y) + this->actor.world.pos.y;
sp48.z = (2.0f * this->unk_31C.z) + this->actor.world.pos.z;
posA.x = (2.0f * this->unk_31C.x) + this->actor.world.pos.x;
posA.y = (2.0f * this->unk_31C.y) + this->actor.world.pos.y;
posA.z = (2.0f * this->unk_31C.z) + this->actor.world.pos.z;
sp3C.x = (this->unk_31C.x * -4.0f) + this->actor.world.pos.x;
sp3C.y = (this->unk_31C.y * -4.0f) + this->actor.world.pos.y;
sp3C.z = (this->unk_31C.z * -4.0f) + this->actor.world.pos.z;
posB.x = (this->unk_31C.x * -4.0f) + this->actor.world.pos.x;
posB.y = (this->unk_31C.y * -4.0f) + this->actor.world.pos.y;
posB.z = (this->unk_31C.z * -4.0f) + this->actor.world.pos.z;
if (func_800C55C4(&globalCtx->colCtx, &sp48, &sp3C, &this->unk_33C, &this->unk_334, 1, 1, 1, 1, &this->unk_338)) {
if (BgCheck_EntityLineTest1(&globalCtx->colCtx, &posA, &posB, &this->unk_33C, &this->poly, true, true, true, true,
&this->polyBgId)) {
this->unk_30C |= 0xA;
return true;
}
@ -496,21 +498,22 @@ s32 func_80A6958C(EnMushi2* this, GlobalContext* globalCtx) {
s32 func_80A6969C(EnMushi2* this, GlobalContext* globalCtx) {
s32 pad;
Vec3f sp50;
Vec3f sp44;
Vec3f posA;
Vec3f posB;
Vec3f sp38;
sp38.x = this->unk_31C.x * -4.0f;
sp38.y = this->unk_31C.y * -4.0f;
sp38.z = this->unk_31C.z * -4.0f;
Math_Vec3f_Sum(&sp38, &this->actor.world.pos, &sp50);
Math_Vec3f_Sum(&sp38, &this->actor.world.pos, &posA);
sp44.x = this->actor.prevPos.x + sp38.x + (this->unk_328.x * -4.0f);
sp44.y = this->actor.prevPos.y + sp38.y + (this->unk_328.y * -4.0f);
sp44.z = this->actor.prevPos.z + sp38.z + (this->unk_328.z * -4.0f);
posB.x = this->actor.prevPos.x + sp38.x + (this->unk_328.x * -4.0f);
posB.y = this->actor.prevPos.y + sp38.y + (this->unk_328.y * -4.0f);
posB.z = this->actor.prevPos.z + sp38.z + (this->unk_328.z * -4.0f);
if (func_800C55C4(&globalCtx->colCtx, &sp50, &sp44, &this->unk_33C, &this->unk_334, 1, 1, 1, 1, &this->unk_338)) {
if (BgCheck_EntityLineTest1(&globalCtx->colCtx, &posA, &posB, &this->unk_33C, &this->poly, true, true, true, true,
&this->polyBgId)) {
this->unk_30C |= (0x10 | 0x2);
return true;
}
@ -519,8 +522,8 @@ s32 func_80A6969C(EnMushi2* this, GlobalContext* globalCtx) {
void func_80A697C4(EnMushi2* this, GlobalContext* globalCtx) {
s32 pad;
s32 sp38 = this->unk_334;
s32 sp34 = this->unk_338;
CollisionPoly* poly = this->poly;
s32 bgId = this->polyBgId;
if (!(this->unk_30C & (0x10 | 0x4))) {
WaterBox* sp30;
@ -531,8 +534,8 @@ void func_80A697C4(EnMushi2* this, GlobalContext* globalCtx) {
func_80A6969C(this, globalCtx);
}
if (func_800CA1E8(globalCtx, &globalCtx->colCtx, this->actor.world.pos.x, this->actor.world.pos.z, &sp2C,
&sp30)) {
if (WaterBox_GetSurface1_2(globalCtx, &globalCtx->colCtx, this->actor.world.pos.x, this->actor.world.pos.z,
&sp2C, &sp30)) {
this->actor.depthInWater = sp2C - this->actor.world.pos.y;
if (this->actor.depthInWater >= 1.0f) {
this->unk_30C |= 0x20;
@ -547,11 +550,11 @@ void func_80A697C4(EnMushi2* this, GlobalContext* globalCtx) {
if (this->unk_30C & 4) {
Math_Vec3f_Copy(&this->actor.world.pos, &this->unk_33C);
if (func_80A691EC(this, this->unk_334, 0.4f) == 1) {
if (func_80A691EC(this, this->poly, 0.4f) == 1) {
this->unk_30C &= ~0x4;
}
} else if (this->unk_30C & 0x10) {
if (func_80A691EC(this, this->unk_334, 0.4f) == 1) {
if (func_80A691EC(this, this->poly, 0.4f) == 1) {
this->unk_30C &= ~0x10;
Math_Vec3f_Copy(&this->actor.world.pos, &this->unk_33C);
} else {
@ -560,13 +563,13 @@ void func_80A697C4(EnMushi2* this, GlobalContext* globalCtx) {
} else if (this->unk_30C & 8) {
if (!(this->unk_30C & 0x20)) {
Math_Vec3f_Copy(&this->actor.world.pos, &this->unk_33C);
func_80A691EC(this, this->unk_334, -1.0f);
func_80A691EC(this, this->poly, -1.0f);
}
} else if (!(this->unk_30C & 2)) {
Math_Vec3f_Copy(&this->actor.world.pos, &this->actor.prevPos);
Math_Vec3f_Copy(&this->unk_33C, &this->actor.prevPos);
this->unk_334 = sp38;
this->unk_338 = sp34;
this->poly = poly;
this->polyBgId = bgId;
}
}
@ -580,7 +583,7 @@ s32 func_80A699E4(EnMushi2* this, GlobalContext* globalCtx) {
f32 y = (2.0f * this->unk_328.y) + this->actor.world.pos.y;
f32 z = (2.0f * this->unk_328.z) + this->actor.world.pos.z;
if (func_800CA1E8(globalCtx, &globalCtx->colCtx, x, z, &sp3C, &sp40) && (y <= sp3C)) {
if (WaterBox_GetSurface1_2(globalCtx, &globalCtx->colCtx, x, z, &sp3C, &sp40) && (y <= sp3C)) {
return true;
}
}
@ -676,13 +679,13 @@ void func_80A69D3C(EnMushi2* this) {
s32 func_80A69EE4(EnMushi2* this, GlobalContext* globalCtx) {
s32 pad;
WaterBox* sp30;
f32 sp2C;
s32 sp28;
WaterBox* waterBox;
f32 waterSurface;
s32 bgId;
if (func_800C9EBC(globalCtx, &globalCtx->colCtx, this->actor.world.pos.x, this->actor.world.pos.z, &sp2C, &sp30,
&sp28) &&
(this->actor.world.pos.y < sp2C)) {
if (WaterBox_GetSurfaceImpl(globalCtx, &globalCtx->colCtx, this->actor.world.pos.x, this->actor.world.pos.z,
&waterSurface, &waterBox, &bgId) &&
(this->actor.world.pos.y < waterSurface)) {
return true;
}
return false;
@ -1083,8 +1086,8 @@ void func_80A6B0D8(EnMushi2* this, GlobalContext* globalCtx) {
Vec3f sp48;
s32 sp44 = 0;
if (this->unk_334 != 0) {
u32 temp_v0 = func_800C99D4(&globalCtx->colCtx, this->unk_334, this->unk_338);
if (this->poly != NULL) {
u32 temp_v0 = func_800C99D4(&globalCtx->colCtx, this->poly, this->polyBgId);
if ((temp_v0 == 5) || (temp_v0 == 14) || (temp_v0 == 15)) {
sp44 = 1;
}
@ -1151,8 +1154,8 @@ void EnMushi2_Update(Actor* thisx, GlobalContext* globalCtx) {
this->unk_358 = 1.0f;
}
temp = this->unk_338;
if ((temp != 50) &&
temp = this->polyBgId;
if ((temp != BGCHECK_SCENE) &&
((this->actionFunc == func_80A6A5C0) || (this->actionFunc == func_80A6A824) ||
(this->actionFunc == func_80A6A9E4) || (this->actionFunc == func_80A6B0D8)) &&
BgCheck2_UpdateActorAttachedToMesh(&globalCtx->colCtx, temp, &this->actor)) {
@ -1176,13 +1179,12 @@ void EnMushi2_Update(Actor* thisx, GlobalContext* globalCtx) {
if (this->unk_34C != 0) {
sp4C = 0.0f;
this->unk_354 = Math3D_DistanceSquared(&this->actor.world.pos, &this->unk_34C->actor.world.pos);
this->unk_354 = Math3D_Vec3fDistSq(&this->actor.world.pos, &this->unk_34C->actor.world.pos);
if (this->unk_354 < this->unk_350) {
f32 dist = Math3D_NormalizedSignedDistanceFromPlane(
COLPOLY_GET_NORMAL(this->unk_34C->actor.floorPoly->normal.x),
COLPOLY_GET_NORMAL(this->unk_34C->actor.floorPoly->normal.y),
COLPOLY_GET_NORMAL(this->unk_34C->actor.floorPoly->normal.z), this->unk_34C->actor.floorPoly->dist,
&this->actor.world.pos);
f32 dist = Math3D_DistPlaneToPos(COLPOLY_GET_NORMAL(this->unk_34C->actor.floorPoly->normal.x),
COLPOLY_GET_NORMAL(this->unk_34C->actor.floorPoly->normal.y),
COLPOLY_GET_NORMAL(this->unk_34C->actor.floorPoly->normal.z),
this->unk_34C->actor.floorPoly->dist, &this->actor.world.pos);
if (fabsf(dist) < 3.0f) {
sp4C = 1.9f;

4
src/overlays/actors/ovl_En_Mushi2/z_en_mushi2.h
View File

@ -26,8 +26,8 @@ typedef struct EnMushi2 {
/* 0x0310 */ Vec3f unk_310;
/* 0x031C */ Vec3f unk_31C;
/* 0x0328 */ Vec3f unk_328;
/* 0x0334 */ CollisionPoly* unk_334;
/* 0x0338 */ u32 unk_338;
/* 0x0334 */ CollisionPoly* poly;
/* 0x0338 */ s32 polyBgId;
/* 0x033C */ Vec3f unk_33C;
/* 0x0348 */ f32 unk_348;
/* 0x034C */ struct ObjBean* unk_34C;

2
src/overlays/actors/ovl_En_Niw/z_en_niw.c
View File

@ -810,7 +810,7 @@ void EnNiw_Update(Actor* thisx, GlobalContext* globalCtx) {
Actor_UpdateBgCheckInfo(globalCtx, &this->actor, 20.0f, 20.0f, 60.0f, 0x1F);
if ((this->actor.floorHeight <= BGCHECK_Y_MIN) || (this->actor.floorHeight >= 32000.0f)) {
if (this->actor.floorHeight <= BGCHECK_Y_MIN || this->actor.floorHeight >= BGCHECK_Y_MAX) {
// if cucco is off the map?
Vec3f camera;
camera.x = globalCtx->view.at.x - globalCtx->view.eye.x;

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

@ -94,7 +94,7 @@ void EnNutsball_Update(Actor* thisx, GlobalContext* globalCtx) {
Vec3s worldRot;
Vec3f spawnBurstPos;
f32 spdXZ;
u32 bgId;
s32 bgId;
CollisionPoly* poly;
if (!(player->stateFlags1 & 0x300000C0)) {
@ -140,8 +140,8 @@ void EnNutsball_Update(Actor* thisx, GlobalContext* globalCtx) {
if (this->actor.bgCheckFlags & 8) {
if (func_800C9A4C(&globalCtx2->colCtx, this->actor.wallPoly, this->actor.wallBgId) & 0x30) {
this->actor.bgCheckFlags &= ~8;
if (func_800C55C4(&globalCtx2->colCtx, &this->actor.prevPos, &worldPos, &this->actor.world.pos, &poly,
1, 0, 0, 1, &bgId)) {
if (BgCheck_EntityLineTest1(&globalCtx2->colCtx, &this->actor.prevPos, &worldPos,
&this->actor.world.pos, &poly, true, false, false, true, &bgId)) {
if (func_800C9A4C(&globalCtx2->colCtx, poly, bgId) & 0x30) {
this->actor.world.pos.x += this->actor.velocity.x * 0.01f;
this->actor.world.pos.z += this->actor.velocity.z * 0.01f;

15
src/overlays/actors/ovl_En_Ot/z_en_ot.c
View File

@ -138,7 +138,7 @@ void func_80B5B2E0(GlobalContext* globalCtx, Vec3f* pos, s16 params, Vec3f* vec,
void EnOt_Init(Actor* thisx, GlobalContext* globalCtx) {
s32 pad;
EnOt* this = THIS;
s32 sp74;
s32 bgId;
s32 pad2;
Vec3f sp64;
Vec3f sp58;
@ -183,9 +183,9 @@ void EnOt_Init(Actor* thisx, GlobalContext* globalCtx) {
switch (this->unk_344) {
case 0:
this->actor.world.pos.y =
func_800C40B4(&globalCtx->colCtx, &this->actor.floorPoly, &sp74, &this->actor.world.pos) +
50.0f;
this->actor.world.pos.y = BgCheck_EntityRaycastFloor3(&globalCtx->colCtx, &this->actor.floorPoly,
&bgId, &this->actor.world.pos) +
50.0f;
if (gSaveContext.weekEventReg[84] & 0x10) {
Matrix_RotateY(this->actor.shape.rot.y, MTXMODE_NEW);
Matrix_GetStateTranslationAndScaledZ(52.519997f, &sp64);
@ -242,7 +242,8 @@ void EnOt_Init(Actor* thisx, GlobalContext* globalCtx) {
} else {
Player* player = GET_PLAYER(globalCtx);
if (func_800C9B90(&globalCtx->colCtx, player->actor.floorPoly, player->actor.floorBgId)) {
if (SurfaceType_IsHorseBlocked(&globalCtx->colCtx, player->actor.floorPoly,
player->actor.floorBgId)) {
Actor_SetScale(&this->actor, 0.0f);
func_80B5C910(this, globalCtx);
} else {
@ -1007,7 +1008,7 @@ void func_80B5DB6C(Actor* thisx, GlobalContext* globalCtx) {
s32 sp4C = false;
if (gSaveContext.weekEventReg[13] & 1) {
if (!func_800C9B90(&globalCtx->colCtx, player->actor.floorPoly, player->actor.floorBgId)) {
if (!SurfaceType_IsHorseBlocked(&globalCtx->colCtx, player->actor.floorPoly, player->actor.floorBgId)) {
sp4C = true;
}
}
@ -1021,7 +1022,7 @@ void func_80B5DB6C(Actor* thisx, GlobalContext* globalCtx) {
temp->actor.cutscene = this->actor.cutscene;
this->unk_32C |= 8;
}
} else if (func_800C9B90(&globalCtx->colCtx, player->actor.floorPoly, player->actor.floorBgId)) {
} else if (SurfaceType_IsHorseBlocked(&globalCtx->colCtx, player->actor.floorPoly, player->actor.floorBgId)) {
player->unk_B2B = 29;
}
}

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

@ -370,7 +370,7 @@ void EnPametfrog_StopCutscene(EnPametfrog* this, GlobalContext* globalCtx) {
void EnPametfrog_PlaceSnapper(EnPametfrog* this, GlobalContext* globalCtx) {
CollisionPoly* poly;
u32 bgId;
s32 bgId;
Vec3f vec1;
Vec3f vec2;
Vec3f vec3;
@ -386,7 +386,7 @@ void EnPametfrog_PlaceSnapper(EnPametfrog* this, GlobalContext* globalCtx) {
vec3.x = this->actor.child->world.pos.x;
vec3.y = this->actor.child->world.pos.y - 150.0f;
vec3.z = this->actor.child->world.pos.z;
if (func_800C55C4(&globalCtx->colCtx, &vec2, &vec3, &vec1, &poly, 0, 1, 0, 1, &bgId) != 0) {
if (BgCheck_EntityLineTest1(&globalCtx->colCtx, &vec2, &vec3, &vec1, &poly, false, true, false, true, &bgId)) {
this->actor.child->floorHeight = vec1.y;
} else {
this->actor.child->floorHeight = this->actor.home.pos.y;
@ -615,8 +615,8 @@ void EnPametfrog_WallCrawl(EnPametfrog* this, GlobalContext* globalCtx) {
Vec3f worldPos1;
Vec3f worldPos2;
f32 doubleSpeedXZ;
u32 bgId1;
u32 bgId2;
s32 bgId1;
s32 bgId2;
s32 isSuccess = false;
if (this->freezeTimer > 0) {
@ -632,11 +632,13 @@ void EnPametfrog_WallCrawl(EnPametfrog* this, GlobalContext* globalCtx) {
vec2.x = this->actor.world.pos.x - this->unk_2DC.x * 25.0f;
vec2.y = this->actor.world.pos.y - this->unk_2DC.y * 25.0f;
vec2.z = this->actor.world.pos.z - this->unk_2DC.z * 25.0f;
if (func_800C55C4(&globalCtx->colCtx, &vec1, &vec2, &worldPos2, &poly2, 1, 1, 1, 1, &bgId2) != 0) {
if (BgCheck_EntityLineTest1(&globalCtx->colCtx, &vec1, &vec2, &worldPos2, &poly2, true, true, true, true,
&bgId2)) {
vec2.x = this->unk_2D0.x * doubleSpeedXZ + vec1.x;
vec2.y = this->unk_2D0.y * doubleSpeedXZ + vec1.y;
vec2.z = this->unk_2D0.z * doubleSpeedXZ + vec1.z;
if (func_800C55C4(&globalCtx->colCtx, &vec1, &vec2, &worldPos1, &poly1, 1, 1, 1, 1, &bgId1) != 0) {
if (BgCheck_EntityLineTest1(&globalCtx->colCtx, &vec1, &vec2, &worldPos1, &poly1, true, true, true, true,
&bgId1)) {
isSuccess = func_8086A2CC(this, poly1);
Math_Vec3f_Copy(&this->actor.world.pos, &worldPos1);
this->actor.floorBgId = bgId1;

13
src/overlays/actors/ovl_En_Po_Sisters/z_en_po_sisters.c
View File

@ -901,8 +901,8 @@ void EnPoSisters_Update(Actor* thisx, GlobalContext* globalCtx) {
s32 pad;
EnPoSisters* this = THIS;
f32 temp_f2;
Vec3f sp40;
s32 sp3C;
Vec3f checkPos;
s32 bgId;
if (this->collider.base.atFlags & AT_HIT) {
this->collider.base.atFlags &= ~AT_HIT;
@ -925,10 +925,11 @@ void EnPoSisters_Update(Actor* thisx, GlobalContext* globalCtx) {
if (this->unk_191 & 0x10) {
Actor_UpdateBgCheckInfo(globalCtx, &this->actor, 20.0f, 20.0f, 0.0f, 5);
} else {
sp40.x = this->actor.world.pos.x;
sp40.y = this->actor.world.pos.y + 10.0f;
sp40.z = this->actor.world.pos.z;
this->actor.floorHeight = func_800C411C(&globalCtx->colCtx, &this->actor.floorPoly, &sp3C, &this->actor, &sp40);
checkPos.x = this->actor.world.pos.x;
checkPos.y = this->actor.world.pos.y + 10.0f;
checkPos.z = this->actor.world.pos.z;
this->actor.floorHeight =
BgCheck_EntityRaycastFloor5(&globalCtx->colCtx, &this->actor.floorPoly, &bgId, &this->actor, &checkPos);
}
this->actor.shape.shadowAlpha = this->unk_229;

12
src/overlays/actors/ovl_En_Suttari/z_en_suttari.c
View File

@ -201,14 +201,14 @@ void EnSuttari_UpdateTime(void) {
}
s32 func_80BAA904(EnSuttari* this, GlobalContext* globalCtx) {
Vec3f sp2C;
Vec3f pos;
s32 pad;
s32 sp24;
CollisionPoly* poly;
sp2C.x = (Math_SinS(this->actor.world.rot.y) * 50.0f) + this->actor.world.pos.x;
sp2C.y = this->actor.world.pos.y + 100.0f;
sp2C.z = (Math_CosS(this->actor.world.rot.y) * 50.0f) + this->actor.world.pos.z;
if (func_800C4000(globalCtx, &globalCtx->colCtx, &sp24, &sp2C) > -500.0f) {
pos.x = (Math_SinS(this->actor.world.rot.y) * 50.0f) + this->actor.world.pos.x;
pos.y = this->actor.world.pos.y + 100.0f;
pos.z = (Math_CosS(this->actor.world.rot.y) * 50.0f) + this->actor.world.pos.z;
if (BgCheck_EntityRaycastFloor2(globalCtx, &globalCtx->colCtx, &poly, &pos) > -500.0f) {
return false;
}
return true;

15
src/overlays/actors/ovl_En_Sw/z_en_sw.c
View File

@ -360,11 +360,12 @@ void func_808D93BC(EnSw* this) {
this->actor.world.rot.x = -this->actor.world.rot.x;
}
s32 func_808D9440(GlobalContext* globalCtx, Vec3f* arg1, Vec3f* arg2, Vec3f* arg3, CollisionPoly** arg4, u32* arg5) {
s32 func_808D9440(GlobalContext* globalCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly,
s32* bgId) {
s32 ret = false;
if (func_800C55C4(&globalCtx->colCtx, arg1, arg2, arg3, arg4, 1, 1, 1, 1, arg5) &&
!(func_800C9A4C(&globalCtx->colCtx, *arg4, *arg5) & 0x30)) {
if (BgCheck_EntityLineTest1(&globalCtx->colCtx, posA, posB, posResult, outPoly, true, true, true, true, bgId) &&
!(func_800C9A4C(&globalCtx->colCtx, *outPoly, *bgId) & 0x30)) {
ret = true;
}
return ret;
@ -379,16 +380,16 @@ void func_808D94D0(EnSw* this, GlobalContext* globalCtx, s32 arg2, s32 arg3, s16
Vec3f sp84;
Vec3f sp78;
Vec3f sp6C;
u32 sp68;
u32 sp64;
s32 sp68;
s32 sp64;
Actor* thisx = &this->actor;
f32 temp_f20;
s32 i;
spA4 = NULL;
spA0 = NULL;
sp68 = 50;
sp64 = 50;
sp68 = BGCHECK_SCENE;
sp64 = BGCHECK_SCENE;
func_808D90F0(this, arg3, arg4);
this->actor.speedXZ = this->unk_44C;
temp_f20 = thisx->speedXZ * 2.0f;

6
src/overlays/actors/ovl_En_Tite/z_en_tite.c
View File

@ -251,13 +251,13 @@ void func_80893BCC(EnTite* this, GlobalContext* globalCtx) {
s32 j;
if (this->actor.bgCheckFlags & 2) {
u32 temp_v0 = func_800C9BB8(&globalCtx->colCtx, this->actor.floorPoly, this->actor.floorBgId);
u32 surface = func_800C9BB8(&globalCtx->colCtx, this->actor.floorPoly, this->actor.floorBgId);
if ((temp_v0 == 0) || (temp_v0 == 1)) {
if ((surface == COLPOLY_SURFACE_GROUND) || (surface == COLPOLY_SURFACE_SAND)) {
for (i = 5; i < ARRAY_COUNT(this->unk_2D0); i++) {
func_800BBFB0(globalCtx, &this->unk_2D0[i], 1.0f, 2, 80, 15, 1);
}
} else if (temp_v0 == 14) {
} else if (surface == COLPOLY_SURFACE_SNOW) {
Vec3f* ptr;
for (i = 5; i < ARRAY_COUNT(this->unk_2D0); i++) {

15
src/overlays/actors/ovl_En_Tk/z_en_tk.c
View File

@ -1046,8 +1046,8 @@ s32 func_80AEE86C(EnTk* this, GlobalContext* globalCtx) {
Vec3f sp28;
Lib_Vec3f_TranslateAndRotateY(&this->actor.world.pos, this->actor.shape.rot.y, &D_80AEFA78, &sp28);
if ((func_800C40B4(&globalCtx->colCtx, &sp38, &sp34, &sp28) != BGCHECK_Y_MIN) &&
(func_800C9BB8(&globalCtx->colCtx, sp38, sp34) == 1) && (this->unk_2D0 == 1) &&
if ((BgCheck_EntityRaycastFloor3(&globalCtx->colCtx, &sp38, &sp34, &sp28) != BGCHECK_Y_MIN) &&
(func_800C9BB8(&globalCtx->colCtx, sp38, sp34) == 1) && (this->unk_2D0 == (u32)1) &&
(this->actor.xyzDistToPlayerSq <= SQ(115.0f)) &&
func_80AEE7E0(&this->actor.world.pos, 100.0f, this->unk_324, this->unk_36C) &&
(((this->unk_2CA & 2) && (Math_Vec3f_DistXZ(&this->unk_300, &sp28) >= 100.0f)) || !(this->unk_2CA & 2)) &&
@ -1131,7 +1131,8 @@ void func_80AEEB88(EnTk* this, GlobalContext* globalCtx) {
sp68.y = this->actor.world.pos.y + 50.0f;
sp68.z += this->actor.world.pos.z;
temp = func_800C40B4(&globalCtx->colCtx, &this->actor.floorPoly, &sp74, &sp68) - this->actor.world.pos.y;
temp = BgCheck_EntityRaycastFloor3(&globalCtx->colCtx, &this->actor.floorPoly, &sp74, &sp68) -
this->actor.world.pos.y;
if (temp <= -80.0f) {
break;
}
@ -1160,7 +1161,7 @@ void func_80AEED38(EnTk* this, GlobalContext* globalCtx) {
sp58.y += 30.0f;
sp58.z += Math_CosS(sp56) * 20.0f;
if (func_800C5A64(&globalCtx->colCtx, &sp58, 20.0f)) {
if (BgCheck_SphVsFirstWall(&globalCtx->colCtx, &sp58, 20.0f)) {
Math_Vec3f_Copy(&sp48, &this->actor.world.pos);
sp56 = BINANG_ADD(this->actor.shape.rot.y, 0x4000);
sp48.x += (Math_SinS(sp56) * 20.0f);
@ -1173,8 +1174,8 @@ void func_80AEED38(EnTk* this, GlobalContext* globalCtx) {
sp3C.y += 30.0f;
sp3C.z += Math_CosS(sp56) * 20.0f;
if (func_800C5A64(&globalCtx->colCtx, &sp48, 20.0f)) {
if (func_800C5A64(&globalCtx->colCtx, &sp3C, 20.0f)) {
if (BgCheck_SphVsFirstWall(&globalCtx->colCtx, &sp48, 20.0f)) {
if (BgCheck_SphVsFirstWall(&globalCtx->colCtx, &sp3C, 20.0f)) {
this->unk_2CC = this->actor.shape.rot.y - 0x4000;
} else {
this->unk_2CC = this->actor.shape.rot.y - 0x4000;
@ -1297,7 +1298,7 @@ void EnTk_Update(Actor* thisx, GlobalContext* globalCtx) {
this->unk_2CA &= ~1;
if (this->actor.floorBgId != BGCHECK_SCENE) {
BgDanpeiMovebg* platform = (BgDanpeiMovebg*)BgCheck_GetActorOfMesh(&globalCtx->colCtx, this->actor.floorBgId);
BgDanpeiMovebg* platform = (BgDanpeiMovebg*)DynaPoly_GetActor(&globalCtx->colCtx, this->actor.floorBgId);
if (platform != NULL) {
if (platform->dyna.actor.id == ACTOR_BG_DANPEI_MOVEBG) {

4
src/overlays/actors/ovl_Obj_Aqua/z_obj_aqua.c
View File

@ -133,8 +133,8 @@ s32 func_80ACBA60(ObjAqua* this, GlobalContext* globalCtx) {
f32 ySurface;
s32 bgId;
if (func_800C9EBC(globalCtx, &globalCtx->colCtx, this->actor.world.pos.x, this->actor.world.pos.z, &ySurface,
&waterBox, &bgId) &&
if (WaterBox_GetSurfaceImpl(globalCtx, &globalCtx->colCtx, this->actor.world.pos.x, this->actor.world.pos.z,
&ySurface, &waterBox, &bgId) &&
(this->actor.world.pos.y < ySurface)) {
return true;
}

2
src/overlays/actors/ovl_Obj_Bell/z_obj_bell.c
View File

@ -275,7 +275,7 @@ void ObjBell_Init(Actor* thisx, GlobalContext* globalCtx) {
void ObjBell_Destroy(Actor* thisx, GlobalContext* globalCtx) {
ObjBell* this = THIS;
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
Collider_DestroySphere(globalCtx, &this->collider1);
Collider_DestroySphere(globalCtx, &this->collider2);
}

10
src/overlays/actors/ovl_Obj_Etcetera/z_obj_etcetera.c
View File

@ -88,7 +88,7 @@ void ObjEtcetera_Init(Actor* thisx, GlobalContext* globalCtx) {
pos.x = this->dyna.actor.world.pos.x;
pos.y = this->dyna.actor.world.pos.y + 10.0f;
pos.z = this->dyna.actor.world.pos.z;
func_800C411C(&globalCtx->colCtx, &this->dyna.actor.floorPoly, &floorBgId, &this->dyna.actor, &pos);
BgCheck_EntityRaycastFloor5(&globalCtx->colCtx, &this->dyna.actor.floorPoly, &floorBgId, &this->dyna.actor, &pos);
this->dyna.actor.floorBgId = floorBgId;
Collider_InitAndSetCylinder(globalCtx, &this->collider, &this->dyna.actor, &sCylinderInit);
Collider_UpdateCylinder(&this->dyna.actor, &this->collider);
@ -101,7 +101,7 @@ void ObjEtcetera_Init(Actor* thisx, GlobalContext* globalCtx) {
void ObjEtcetera_Destroy(Actor* thisx, GlobalContext* globalCtx) {
ObjEtcetera* this = THIS;
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
Collider_DestroyCylinder(globalCtx, &this->collider);
}
@ -236,9 +236,9 @@ void ObjEtcetera_Setup(ObjEtcetera* this, GlobalContext* globalCtx) {
DynaPolyActor_Init(&this->dyna, 1);
thisCollisionHeader = collisionHeaders[type];
if (thisCollisionHeader != 0) {
BgCheck_RelocateMeshHeader(thisCollisionHeader, &colHeader);
CollisionHeader_GetVirtual(thisCollisionHeader, &colHeader);
}
this->dyna.bgId = BgCheck_AddActorMesh(globalCtx, &globalCtx->colCtx.dyna, &this->dyna, colHeader);
this->dyna.bgId = DynaPoly_SetBgActor(globalCtx, &globalCtx->colCtx.dyna, &this->dyna.actor, colHeader);
type = DEKU_FLOWER_TYPE(&this->dyna.actor);
switch (type) {
@ -292,7 +292,7 @@ void ObjEtcetera_Update(Actor* thisx, GlobalContext* globalCtx) {
if (floorBgId == BGCHECK_SCENE) {
floorPoly = this->dyna.actor.floorPoly;
if (floorPoly != NULL && this->burrowFlag & 1) {
func_800FAAB4(globalCtx, func_800C9C9C(&globalCtx->colCtx, floorPoly, floorBgId));
func_800FAAB4(globalCtx, SurfaceType_GetLightSettingIndex(&globalCtx->colCtx, floorPoly, floorBgId));
}
}
this->actionFunc(this, globalCtx);

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

@ -154,8 +154,8 @@ void ObjGhaka_Init(Actor* thisx, GlobalContext* globalCtx) {
Actor_ProcessInitChain(&this->dyna.actor, D_80B3C96C);
Actor_SetScale(&this->dyna.actor, 0.1f);
DynaPolyActor_Init(&this->dyna, 1);
BgCheck_RelocateMeshHeader(&D_06003CD0, &colHeader);
this->dyna.bgId = BgCheck_AddActorMesh(globalCtx, &globalCtx->colCtx.dyna, &this->dyna, colHeader);
CollisionHeader_GetVirtual(&D_06003CD0, &colHeader);
this->dyna.bgId = DynaPoly_SetBgActor(globalCtx, &globalCtx->colCtx.dyna, &this->dyna.actor, colHeader);
Actor_UpdateBgCheckInfo(globalCtx, &this->dyna.actor, 0.0f, 0.0f, 0.0f, 0x4);
if (this->dyna.actor.floorPoly == 0) {
Actor_MarkForDeath(&this->dyna.actor);
@ -169,7 +169,7 @@ void ObjGhaka_Init(Actor* thisx, GlobalContext* globalCtx) {
void ObjGhaka_Destroy(Actor* thisx, GlobalContext* globalCtx) {
ObjGhaka* this = THIS;
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
}
void ObjGhaka_Update(Actor* thisx, GlobalContext* globalCtx) {

8
src/overlays/actors/ovl_Obj_Hgdoor/z_obj_hgdoor.c
View File

@ -80,11 +80,11 @@ void ObjHgdoor_Init(Actor* thisx, GlobalContext* globalCtx) {
Actor_SetScale(&this->dyna.actor, 0.1f);
DynaPolyActor_Init(&this->dyna, 1);
if (OBJHGDOOR_IS_RIGHT_DOOR(&this->dyna.actor)) {
BgCheck_RelocateMeshHeader(&D_06001D10, &header);
CollisionHeader_GetVirtual(&D_06001D10, &header);
} else {
BgCheck_RelocateMeshHeader(&D_060018C0, &header);
CollisionHeader_GetVirtual(&D_060018C0, &header);
}
this->dyna.bgId = BgCheck_AddActorMesh(globalCtx, &globalCtx->colCtx.dyna, &this->dyna, header);
this->dyna.bgId = DynaPoly_SetBgActor(globalCtx, &globalCtx->colCtx.dyna, &this->dyna.actor, header);
this->rotation = 0;
this->timer = 0;
this->cutscene = this->dyna.actor.cutscene;
@ -94,7 +94,7 @@ void ObjHgdoor_Init(Actor* thisx, GlobalContext* globalCtx) {
void ObjHgdoor_Destroy(Actor* thisx, GlobalContext* globalCtx) {
ObjHgdoor* this = THIS;
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
}
void ObjHgdoor_SetupCheckShouldOpen(ObjHgdoor* this) {

2
src/overlays/actors/ovl_Obj_HsStump/z_obj_hsstump.c
View File

@ -136,7 +136,7 @@ void ObjHsStump_Appear(ObjHsStump* this, GlobalContext* globalCtx) {
void ObjHsStump_Destroy(Actor* thisx, GlobalContext* globalCtx) {
ObjHsStump* this = THIS;
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
}
void ObjHsStump_Update(Actor* thisx, GlobalContext* globalCtx) {

4
src/overlays/actors/ovl_Obj_Kepn_Koya/z_obj_kepn_koya.c
View File

@ -42,7 +42,7 @@ void ObjKepnKoya_Init(Actor* thisx, GlobalContext* globalCtx) {
Actor_SetScale(&this->dyna.actor, 0.1f);
DynaPolyActor_Init(&this->dyna, 0);
DynaPolyActor_LoadMesh(globalCtx, &this->dyna, &D_0600805C);
if (this->dyna.bgId == 0x32) {
if (this->dyna.bgId == BG_ACTOR_MAX) {
Actor_MarkForDeath(&this->dyna.actor);
}
}
@ -50,7 +50,7 @@ void ObjKepnKoya_Init(Actor* thisx, GlobalContext* globalCtx) {
void ObjKepnKoya_Destroy(Actor* thisx, GlobalContext* globalCtx) {
ObjKepnKoya* this = THIS;
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
}
void ObjKepnKoya_Update(Actor* thisx, GlobalContext* globalCtx) {

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

@ -298,7 +298,7 @@ void ObjKibako_Idle(ObjKibako* this, GlobalContext* globalCtx) {
}
if ((this->actor.colChkInfo.mass != MASS_IMMOVABLE) &&
(Math3D_DistanceSquared(&this->actor.world.pos, &this->actor.prevPos) < 0.01f)) {
(Math3D_Vec3fDistSq(&this->actor.world.pos, &this->actor.prevPos) < 0.01f)) {
this->actor.colChkInfo.mass = MASS_IMMOVABLE;
}
@ -333,7 +333,7 @@ void ObjKibako_SetupHeld(ObjKibako* this) {
void ObjKibako_Held(ObjKibako* this, GlobalContext* globalCtx) {
s32 pad;
Vec3f pos;
s32 sp2C;
s32 bgId;
func_80926394(this, globalCtx);
if (Actor_HasNoParent(&this->actor, globalCtx)) {
@ -352,7 +352,8 @@ void ObjKibako_Held(ObjKibako* this, GlobalContext* globalCtx) {
pos.x = this->actor.world.pos.x;
pos.y = this->actor.world.pos.y + 20.0f;
pos.z = this->actor.world.pos.z;
this->actor.floorHeight = func_800C411C(&globalCtx->colCtx, &this->actor.floorPoly, &sp2C, &this->actor, &pos);
this->actor.floorHeight =
BgCheck_EntityRaycastFloor5(&globalCtx->colCtx, &this->actor.floorPoly, &bgId, &this->actor, &pos);
}
}

6
src/overlays/actors/ovl_Obj_Kibako2/z_obj_kibako2.c
View File

@ -177,7 +177,7 @@ void ObjKibako2_Destroy(Actor* thisx, GlobalContext* globalCtx) {
ObjKibako2* this = THIS;
Collider_DestroyCylinder(globalCtx, &this->collider);
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
}
s32 ObjKibako2_ShouldBreak(ObjKibako2* this) {
@ -190,12 +190,12 @@ s32 ObjKibako2_ShouldBreak(ObjKibako2* this) {
if (ac != NULL) {
if (this->collider.info.acHitInfo->toucher.dmgFlags & (1 << 31)) {
// Powder Keg
if (Math3D_DistanceSquared(&this->dyna.actor.world.pos, &ac->world.pos) < SQ(160.0f)) {
if (Math3D_Vec3fDistSq(&this->dyna.actor.world.pos, &ac->world.pos) < SQ(160.0f)) {
shouldBreak = true;
}
} else if (this->collider.info.acHitInfo->toucher.dmgFlags & (1 << 3)) {
// Explosives
if (Math3D_DistanceSquared(&this->dyna.actor.world.pos, &ac->world.pos) < SQ(100.0f)) {
if (Math3D_Vec3fDistSq(&this->dyna.actor.world.pos, &ac->world.pos) < SQ(100.0f)) {
shouldBreak = true;
}
} else if (this->collider.info.acHitInfo->toucher.dmgFlags & (1 << 8 | 1 << 10)) {

2
src/overlays/actors/ovl_Obj_Lightblock/z_obj_lightblock.c
View File

@ -110,7 +110,7 @@ void ObjLightblock_Init(Actor* thisx, GlobalContext* globalCtx) {
void ObjLightblock_Destroy(Actor* thisx, GlobalContext* globalCtx) {
ObjLightblock* this = THIS;
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
Collider_DestroyCylinder(globalCtx, &this->collider);
}

2
src/overlays/actors/ovl_Obj_Makeoshihiki/z_obj_makeoshihiki.c
View File

@ -85,7 +85,7 @@ void ObjMakeoshihiki_Update(Actor* thisx, GlobalContext* globalCtx) {
} else {
for (loopPathIndex = 0; loopPathIndex < this->pathCount; loopPathIndex++) {
Math_Vec3s_ToVec3f(&pathPointF, &this->pathPoints[loopPathIndex]);
if (Math3D_DistanceSquared(&this->actor.child->world.pos, &pathPointF) < SQ(0.5f)) {
if (Math3D_Vec3fDistSq(&this->actor.child->world.pos, &pathPointF) < SQ(0.5f)) {
ObjMakeoshihiki_SetSwitchFlags(this, globalCtx, loopPathIndex);
return;
}

2
src/overlays/actors/ovl_Obj_Raillift/z_obj_raillift.c
View File

@ -107,7 +107,7 @@ void ObjRaillift_Init(Actor* thisx, GlobalContext* globalCtx) {
void ObjRaillift_Destroy(Actor* thisx, GlobalContext* globalCtx) {
ObjRaillift* this = THIS;
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
}
void ObjRaillift_DoNothing(ObjRaillift* this, GlobalContext* globalCtx) {

4
src/overlays/actors/ovl_Obj_Syokudai/z_obj_syokudai.c
View File

@ -155,8 +155,8 @@ void ObjSyokudai_Update(Actor* thisx, GlobalContext* globalCtx2) {
this->pendingAction = OBJ_SYOKUDAI_PENDING_ACTION_NONE;
}
} else {
if (func_800CA1E8(globalCtx, &globalCtx->colCtx, thisx->world.pos.x, thisx->world.pos.z, &waterSurface,
&waterBox) &&
if (WaterBox_GetSurface1_2(globalCtx, &globalCtx->colCtx, thisx->world.pos.x, thisx->world.pos.z, &waterSurface,
&waterBox) &&
((waterSurface - thisx->world.pos.y) > OBJ_SYOKUDAI_FLAME_HEIGHT)) {
this->snuffTimer = OBJ_SYOKUDAI_SNUFF_OUT;

2
src/overlays/actors/ovl_Obj_Tokei_Step/z_obj_tokei_step.c
View File

@ -214,7 +214,7 @@ void ObjTokeiStep_Init(Actor* thisx, GlobalContext* globalCtx) {
void ObjTokeiStep_Destroy(Actor* thisx, GlobalContext* globalCtx) {
ObjTokeiStep* this = THIS;
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
}
void ObjTokeiStep_SetupBeginOpen(ObjTokeiStep* this) {

2
src/overlays/actors/ovl_Obj_Visiblock/z_obj_visiblock.c
View File

@ -47,7 +47,7 @@ void ObjVisiblock_Init(Actor* thisx, GlobalContext* globalCtx) {
void ObjVisiblock_Destroy(Actor* thisx, GlobalContext* globalCtx) {
ObjVisiblock* this = THIS;
BgCheck_RemoveActorMesh(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
DynaPoly_DeleteBgActor(globalCtx, &globalCtx->colCtx.dyna, this->dyna.bgId);
}
void ObjVisiblock_Draw(Actor* thisx, GlobalContext* globalCtx) {

364
tools/disasm/functions.txt
View File

@ -899,162 +899,162 @@
0x800BFA78:("ActorOverlayTable_FaultAddrConv",),
0x800BFAE8:("ActorOverlayTable_Init",),
0x800BFB40:("ActorOverlayTable_Cleanup",),
0x800BFB80:("BgCheck_PolygonLinkedListNodeInit",),
0x800BFB9C:("BgCheck_PolygonLinkedListResetHead",),
0x800BFBAC:("BgCheck_ScenePolygonListsNodeInsert",),
0x800BFC04:("BgCheck_PolygonLinkedListNodeInsert",),
0x800BFC5C:("BgCheck_PolygonLinkedListInit",),
0x800BFC70:("BgCheck_PolygonLinkedListAlloc",),
0x800BFCC0:("BgCheck_PolygonLinkedListReset",),
0x800BFCCC:("BgCheck_AllocPolygonLinkedListNode",),
0x800BFCFC:("BgCheck_CreateVec3fFromVertex",),
0x800BFD40:("BgCheck_CreateVertexFromVec3f",),
0x800BFB80:("SSNode_SetValue",),
0x800BFB9C:("SSList_SetNull",),
0x800BFBAC:("SSNodeList_SetSSListHead",),
0x800BFC04:("DynaSSNodeList_SetSSListHead",),
0x800BFC5C:("DynaSSNodeList_Init",),
0x800BFC70:("DynaSSNodeList_Alloc",),
0x800BFCC0:("DynaSSNodeList_ResetCount",),
0x800BFCCC:("DynaSSNodeList_GetNextNodeIdx",),
0x800BFCFC:("BgCheck_Vec3sToVec3f",),
0x800BFD40:("BgCheck_Vec3fToVec3s",),
0x800BFD84:("func_800BFD84",),
0x800BFDEC:("func_800BFDEC",),
0x800BFFC4:("BgCheck_PolygonGetMinY",),
0x800C003C:("BgCheck_PolygonGetNormal",),
0x800BFFC4:("CollisionPoly_GetMinY",),
0x800C003C:("CollisionPoly_GetNormalF",),
0x800C0094:("func_800C0094",),
0x800C01B8:("func_800C01B8",),
0x800C0220:("BgCheck_CreateTriNormFromPolygon",),
0x800C02C0:("func_800C02C0",),
0x800C0340:("func_800C0340",),
0x800C0474:("func_800C0474",),
0x800C0668:("func_800C0668",),
0x800C06A8:("func_800C06A8",),
0x800C074C:("func_800C074C",),
0x800C07F0:("func_800C07F0",),
0x800C0AF0:("BgCheck_PolygonCollidesWithSphere",),
0x800C0BC0:("BgCheck_ScenePolygonListsInsertSorted",),
0x800C0DE0:("BgCheck_ScenePolygonListsInsert",),
0x800C0E74:("func_800C0E74",),
0x800C10FC:("func_800C10FC",),
0x800C1238:("func_800C1238",),
0x800C12A4:("func_800C12A4",),
0x800C1B68:("func_800C1B68",),
0x800C1D7C:("func_800C1D7C",),
0x800C2008:("func_800C2008",),
0x800C20F4:("func_800C20F4",),
0x800C2310:("func_800C2310",),
0x800C2460:("func_800C2460",),
0x800C2514:("func_800C2514",),
0x800C25E0:("func_800C25E0",),
0x800C26C0:("BgCheck_GetPolyMinSubdivisions",),
0x800C2864:("BgCheck_GetPolyMaxSubdivisions",),
0x800C2A30:("BgCheck_GetPolyMinMaxSubdivisions",),
0x800C2BE0:("func_800C2BE0",),
0x800C3334:("BgCheck_SplitScenePolygonsIntoSubdivisions",),
0x800C3734:("BgCheck_GetIsDefaultSpecialScene",),
0x800C3778:("BgCheck_GetSpecialSceneMaxMemory",),
0x800C37BC:("BgCheck_CalcSubdivisionSize",),
0x800C01B8:("CollisionPoly_GetPointDistanceFromPlane",),
0x800C0220:("CollisionPoly_GetVertices",),
0x800C02C0:("CollisionPoly_GetVerticesByBgId",),
0x800C0340:("CollisionPoly_CheckYIntersectApprox1",),
0x800C0474:("CollisionPoly_CheckYIntersect",),
0x800C0668:("CollisionPoly_CheckYIntersectApprox2",),
0x800C06A8:("CollisionPoly_CheckXIntersectApprox",),
0x800C074C:("CollisionPoly_CheckZIntersectApprox",),
0x800C07F0:("CollisionPoly_LineVsPoly",),
0x800C0AF0:("CollisionPoly_SphVsPoly",),
0x800C0BC0:("StaticLookup_AddPolyToSSList",),
0x800C0DE0:("StaticLookup_AddPoly",),
0x800C0E74:("BgCheck_RaycastFloorStaticList",),
0x800C10FC:("BgCheck_RaycastFloorStatic",),
0x800C1238:("BgCheck_ComputeWallDisplacement",),
0x800C12A4:("BgCheck_SphVsStaticWall",),
0x800C1B68:("BgCheck_CheckStaticCeiling",),
0x800C1D7C:("BgCheck_CheckLineAgainstSSList",),
0x800C2008:("BgCheck_CheckLineInSubdivision",),
0x800C20F4:("BgCheck_SphVsFirstStaticPolyList",),
0x800C2310:("BgCheck_SphVsFirstStaticPoly",),
0x800C2460:("BgCheck_GetNearestStaticLookup",),
0x800C2514:("BgCheck_GetStaticLookup",),
0x800C25E0:("BgCheck_GetStaticLookupIndicesFromPos",),
0x800C26C0:("BgCheck_GetSubdivisionMinBounds",),
0x800C2864:("BgCheck_GetSubdivisionMaxBounds",),
0x800C2A30:("BgCheck_GetPolySubdivisionBounds",),
0x800C2BE0:("BgCheck_PolyIntersectsSubdivision",),
0x800C3334:("BgCheck_InitStaticLookup",),
0x800C3734:("BgCheck_IsSmallMemScene",),
0x800C3778:("BgCheck_TryGetCustomMemsize",),
0x800C37BC:("BgCheck_SetSubdivisionDimension",),
0x800C3844:("BgCheck_GetSpecialSceneMaxObjects",),
0x800C389C:("BgCheck_Init",),
0x800C3C00:("func_800C3C00",),
0x800C3C14:("func_800C3C14",),
0x800C3C2C:("BgCheck_GetActorMeshHeader",),
0x800C3C94:("func_800C3C94",),
0x800C3D50:("func_800C3D50",),
0x800C3F40:("func_800C3F40",),
0x800C3FA0:("func_800C3FA0",),
0x800C4000:("func_800C4000",),
0x800C4058:("func_800C4058",),
0x800C40B4:("func_800C40B4",),
0x800C411C:("func_800C411C",),
0x800C4188:("func_800C4188",),
0x800C41E4:("func_800C41E4",),
0x800C4240:("func_800C4240",),
0x800C42A8:("func_800C42A8",),
0x800C4314:("func_800C4314",),
0x800C43CC:("func_800C43CC",),
0x800C4488:("func_800C4488",),
0x800C44F0:("func_800C44F0",),
0x800C455C:("func_800C455C",),
0x800C45C4:("func_800C45C4",),
0x800C4C74:("func_800C4C74",),
0x800C4CD8:("func_800C4CD8",),
0x800C4D3C:("func_800C4D3C",),
0x800C4DA4:("func_800C4DA4",),
0x800C4E10:("func_800C4E10",),
0x800C4F38:("func_800C4F38",),
0x800C4F84:("func_800C4F84",),
0x800C4FD4:("func_800C4FD4",),
0x800C5464:("func_800C5464",),
0x800C54AC:("func_800C54AC",),
0x800C5538:("func_800C5538",),
0x800C55C4:("func_800C55C4",),
0x800C5650:("func_800C5650",),
0x800C56E0:("func_800C56E0",),
0x800C576C:("func_800C576C",),
0x800C57F8:("func_800C57F8",),
0x800C583C:("func_800C583C",),
0x800C58C8:("func_800C58C8",),
0x800C5954:("func_800C5954",),
0x800C5A20:("func_800C5A20",),
0x800C5A64:("func_800C5A64",),
0x800C5AAC:("BgCheck_ScenePolygonListsInit",),
0x800C5AC4:("BgCheck_ScenePolygonListsAlloc",),
0x800C5B80:("func_800C5B80",),
0x800C5BBC:("BgCheck_ScenePolygonListsReserveNode",),
0x800C5BD0:("BgCheck_ActorMeshParamsInit",),
0x800C5C0C:("BgCheck_SetActorMeshParams",),
0x800C5C5C:("BgCheck_AreActorMeshParamsEqual",),
0x800C5D30:("BgCheck_ActorMeshPolyListsHeadsInit",),
0x800C5D70:("BgCheck_ActorMeshPolyListsInit",),
0x800C5D90:("BgCheck_ActorMeshVerticesIndexInit",),
0x800C5D9C:("BgCheck_ActorMeshWaterboxesIndexInit",),
0x800C5DA8:("BgCheck_ActorMeshInit",),
0x800C5E10:("BgCheck_ActorMeshInitFromActor",),
0x800C5EC8:("BgCheck_HasActorMeshChanged",),
0x800C5EF0:("BgCheck_PolygonsInit",),
0x800C5EFC:("BgCheck_PolygonsAlloc",),
0x800C5F38:("BgCheck_VerticesInit",),
0x800C5F44:("BgCheck_VerticesListAlloc",),
0x800C5F8C:("BgCheck_WaterboxListInit",),
0x800C5F9C:("BgCheck_WaterboxListAlloc",),
0x800C5FD8:("BgCheck_ActorMeshUpdateParams",),
0x800C6024:("BgCheck_IsActorMeshIndexValid",),
0x800C6044:("BgCheck_DynaInit",),
0x800C6098:("BgCheck_DynaAlloc",),
0x800C6188:("BgCheck_AddActorMesh",),
0x800C6248:("BgCheck_GetActorOfMesh",),
0x800C389C:("BgCheck_Allocate",),
0x800C3C00:("BgCheck_SetContextFlags",),
0x800C3C14:("BgCheck_UnsetContextFlags",),
0x800C3C2C:("BgCheck_GetCollisionHeader",),
0x800C3C94:("BgCheck_PosInStaticBoundingBox",),
0x800C3D50:("BgCheck_RaycastFloorImpl",),
0x800C3F40:("BgCheck_CameraRaycastFloor1",),
0x800C3FA0:("BgCheck_EntityRaycastFloor1",),
0x800C4000:("BgCheck_EntityRaycastFloor2",),
0x800C4058:("BgCheck_EntityRaycastFloor2_1",),
0x800C40B4:("BgCheck_EntityRaycastFloor3",),
0x800C411C:("BgCheck_EntityRaycastFloor5",),
0x800C4188:("BgCheck_EntityRaycastFloor5_2",),
0x800C41E4:("BgCheck_EntityRaycastFloor5_3",),
0x800C4240:("BgCheck_EntityRaycastFloor6",),
0x800C42A8:("BgCheck_EntityRaycastFloor7",),
0x800C4314:("BgCheck_AnyRaycastFloor1",),
0x800C43CC:("BgCheck_AnyRaycastFloor2",),
0x800C4488:("BgCheck_CameraRaycastFloor2",),
0x800C44F0:("BgCheck_EntityRaycastFloor8",),
0x800C455C:("BgCheck_EntityRaycastFloor9",),
0x800C45C4:("BgCheck_CheckWallImpl",),
0x800C4C74:("BgCheck_EntitySphVsWall1",),
0x800C4CD8:("BgCheck_EntitySphVsWall2",),
0x800C4D3C:("BgCheck_EntitySphVsWall3",),
0x800C4DA4:("BgCheck_EntitySphVsWall4",),
0x800C4E10:("BgCheck_CheckCeilingImpl",),
0x800C4F38:("BgCheck_AnyCheckCeiling",),
0x800C4F84:("BgCheck_EntityCheckCeiling",),
0x800C4FD4:("BgCheck_CheckLineImpl",),
0x800C5464:("BgCheck_GetBccFlags",),
0x800C54AC:("BgCheck_CameraLineTest1",),
0x800C5538:("BgCheck_CameraLineTest2",),
0x800C55C4:("BgCheck_EntityLineTest1",),
0x800C5650:("BgCheck_EntityLineTest2",),
0x800C56E0:("BgCheck_EntityLineTest3",),
0x800C576C:("BgCheck_ProjectileLineTest",),
0x800C57F8:("BgCheck_AnyLineTest1",),
0x800C583C:("BgCheck_AnyLineTest2",),
0x800C58C8:("BgCheck_AnyLineTest3",),
0x800C5954:("BgCheck_SphVsFirstPolyImpl",),
0x800C5A20:("BgCheck_SphVsFirstPoly",),
0x800C5A64:("BgCheck_SphVsFirstWall",),
0x800C5AAC:("SSNodeList_Init",),
0x800C5AC4:("SSNodeList_Alloc",),
0x800C5B80:("SSNodeList_GetNextNode",),
0x800C5BBC:("SSNodeList_GetNextNodeIdx",),
0x800C5BD0:("ScaleRotPos_Init",),
0x800C5C0C:("ScaleRotPos_SetValue",),
0x800C5C5C:("ScaleRotPos_Equals",),
0x800C5D30:("DynaLookup_ResetLists",),
0x800C5D70:("DynaLookup_Reset",),
0x800C5D90:("DynaLookup_ResetVtxStartIndex",),
0x800C5D9C:("DynaLookup_ResetWaterBoxStartIndex",),
0x800C5DA8:("BgActor_Init",),
0x800C5E10:("BgActor_SetActor",),
0x800C5EC8:("BgActor_IsTransformUnchanged",),
0x800C5EF0:("DynaPoly_NullPolyList",),
0x800C5EFC:("DynaPoly_AllocPolyList",),
0x800C5F38:("DynaPoly_NullVtxList",),
0x800C5F44:("DynaPoly_AllocVtxList",),
0x800C5F8C:("DynaPoly_InitWaterBoxList",),
0x800C5F9C:("DynaPoly_AllocWaterBoxList",),
0x800C5FD8:("DynaPoly_SetBgActorPrevTransform",),
0x800C6024:("DynaPoly_IsBgIdBgActor",),
0x800C6044:("DynaPoly_Init",),
0x800C6098:("DynaPoly_Alloc",),
0x800C6188:("DynaPoly_SetBgActor",),
0x800C6248:("DynaPoly_GetActor",),
0x800C62BC:("func_800C62BC",),
0x800C6314:("func_800C6314",),
0x800C636C:("func_800C636C",),
0x800C63C4:("func_800C63C4",),
0x800C641C:("func_800C641C",),
0x800C6474:("func_800C6474",),
0x800C64CC:("BgCheck_RemoveActorMesh",),
0x800C64CC:("DynaPoly_DeleteBgActor",),
0x800C6554:("func_800C6554",),
0x800C656C:("BgCheck_CalcWaterboxDimensions",),
0x800C6838:("BgCheck_AddActorMeshToLists",),
0x800C6838:("DynaPoly_ExpandSRT",),
0x800C734C:("BgCheck_ResetFlagsIfLoadedActor",),
0x800C73E4:("BgCheck_Update",),
0x800C73E4:("DynaPoly_Setup",),
0x800C756C:("func_800C756C",),
0x800C765C:("BgCheck_UpdateAllActorMeshes",),
0x800C76EC:("func_800C76EC",),
0x800C7974:("func_800C7974",),
0x800C7E40:("func_800C7E40",),
0x800C8580:("func_800C8580",),
0x800C87D0:("func_800C87D0",),
0x800C8A60:("func_800C8A60",),
0x800C8BD0:("func_800C8BD0",),
0x800C8DC0:("func_800C8DC0",),
0x800C8EEC:("func_800C8EEC",),
0x800C90AC:("func_800C90AC",),
0x800C921C:("func_800C921C",),
0x800C9380:("func_800C9380",),
0x800C94E0:("BgCheck_RelocateMeshHeaderPointers",),
0x800C9564:("BgCheck_RelocateMeshHeader",),
0x800C9598:("BgCheck_RelocateAllMeshHeaders",),
0x800C9640:("func_800C9640",),
0x800C9694:("BgCheck_GetPolygonAttributes",),
0x800C9704:("func_800C9704",),
0x800C765C:("DynaPoly_UpdateBgActorTransforms",),
0x800C76EC:("BgCheck_RaycastFloorDynaList",),
0x800C7974:("BgCheck_RaycastFloorDyna",),
0x800C7E40:("BgCheck_SphVsDynaWallInBgActor",),
0x800C8580:("BgCheck_SphVsDynaWall",),
0x800C87D0:("BgCheck_CheckDynaCeilingList",),
0x800C8A60:("BgCheck_CheckDynaCeiling",),
0x800C8BD0:("BgCheck_CheckLineAgainstBgActorSSList",),
0x800C8DC0:("BgCheck_CheckLineAgainstBgActor",),
0x800C8EEC:("BgCheck_CheckLineAgainstDyna",),
0x800C90AC:("BgCheck_SphVsFirstDynaPolyList",),
0x800C921C:("BgCheck_SphVsFirstDynaPolyInBgActor",),
0x800C9380:("BgCheck_SphVsFirstDynaPoly",),
0x800C94E0:("CollisionHeader_SegmentedToVirtual",),
0x800C9564:("CollisionHeader_GetVirtual",),
0x800C9598:("BgCheck_InitCollisionHeaders",),
0x800C9640:("BgCheck_ResetPolyCheckTbl",),
0x800C9694:("SurfaceType_GetData",),
0x800C9704:("SurfaceType_GetCamDataIndex",),
0x800C9728:("func_800C9728",),
0x800C9770:("func_800C9770",),
0x800C9770:("SurfaceType_GetCameraSetting",),
0x800C97F8:("func_800C97F8",),
0x800C9844:("func_800C9844",),
0x800C98CC:("func_800C98CC",),
0x800C9924:("func_800C9924",),
0x800C99AC:("func_800C99AC",),
0x800C9924:("SurfaceType_GetCamPosData",),
0x800C99AC:("SurfaceType_GetSceneExitIndex",),
0x800C99D4:("func_800C99D4",),
0x800C99FC:("func_800C99FC",),
0x800C9A24:("func_800C9A24",),
@ -1065,30 +1065,30 @@
0x800C9B18:("func_800C9B18",),
0x800C9B40:("func_800C9B40",),
0x800C9B68:("func_800C9B68",),
0x800C9B90:("func_800C9B90",),
0x800C9B90:("SurfaceType_IsHorseBlocked",),
0x800C9BB8:("func_800C9BB8",),
0x800C9BDC:("func_800C9BDC",),
0x800C9BDC:("SurfaceType_GetSfx",),
0x800C9C24:("func_800C9C24",),
0x800C9C74:("func_800C9C74",),
0x800C9C9C:("func_800C9C9C",),
0x800C9CC4:("func_800C9CC4",),
0x800C9CEC:("func_800C9CEC",),
0x800C9D14:("func_800C9D14",),
0x800C9D50:("func_800C9D50",),
0x800C9D8C:("func_800C9D8C",),
0x800C9C74:("SurfaceType_GetSlope",),
0x800C9C9C:("SurfaceType_GetLightSettingIndex",),
0x800C9CC4:("SurfaceType_GetEcho",),
0x800C9CEC:("SurfaceType_IsHookshotSurface",),
0x800C9D14:("SurfaceType_IsIgnoredByEntities",),
0x800C9D50:("SurfaceType_IsIgnoredByProjectiles",),
0x800C9D8C:("SurfaceType_IsConveyor",),
0x800C9DDC:("func_800C9DDC",),
0x800C9E18:("func_800C9E18",),
0x800C9E40:("func_800C9E40",),
0x800C9E88:("func_800C9E88",),
0x800C9EBC:("func_800C9EBC",),
0x800CA1AC:("func_800CA1AC",),
0x800CA1E8:("func_800CA1E8",),
0x800CA22C:("func_800CA22C",),
0x800C9E18:("SurfaceType_GetConveyorSpeed",),
0x800C9E40:("SurfaceType_GetConveyorDirection",),
0x800C9E88:("SurfaceType_IsWallDamage",),
0x800C9EBC:("WaterBox_GetSurfaceImpl",),
0x800CA1AC:("WaterBox_GetSurface1",),
0x800CA1E8:("WaterBox_GetSurface1_2",),
0x800CA22C:("WaterBox_GetSurface2",),
0x800CA568:("func_800CA568",),
0x800CA634:("func_800CA634",),
0x800CA648:("func_800CA648",),
0x800CA634:("WaterBox_GetCamDataIndex",),
0x800CA648:("WaterBox_GetCameraSetting",),
0x800CA6B8:("func_800CA6B8",),
0x800CA6D8:("func_800CA6D8",),
0x800CA6D8:("WaterBox_GetLightSettingIndex",),
0x800CA6F0:("func_800CA6F0",),
0x800CA9D0:("func_800CA9D0",),
0x800CAA14:("func_800CAA14",),
@ -3256,7 +3256,7 @@
0x80179594:("Rand_ZeroFloat",),
0x801795C0:("randPlusMinusPoint5Scaled",),
0x801795F0:("Math3D_Normalize",),
0x80179678:("func_80179678",),
0x80179678:("Math3D_PlaneVsLineSegClosestPoint",),
0x80179798:("func_80179798",),
0x80179A44:("func_80179A44",),
0x80179B34:("func_80179B34",),
@ -3278,46 +3278,46 @@
0x8017A678:("Math3D_XZDistance",),
0x8017A6A8:("Math3D_LengthSquared",),
0x8017A6D4:("Math3D_Vec3fMagnitude",),
0x8017A6F8:("Math3D_DistanceSquared",),
0x8017A6F8:("Math3D_Vec3fDistSq",),
0x8017A720:("Math3D_Distance",),
0x8017A740:("Math3D_DistanceS",),
0x8017A7B8:("func_8017A7B8",),
0x8017A7F8:("func_8017A7F8",),
0x8017A838:("func_8017A838",),
0x8017A878:("Math3D_CrossProduct",),
0x8017A8EC:("Math3D_NormalVector",),
0x8017A954:("func_8017A954",),
0x8017AA0C:("func_8017AA0C",),
0x8017ABBC:("func_8017ABBC",),
0x8017AD38:("func_8017AD38",),
0x8017A8EC:("Math3D_SurfaceNorm",),
0x8017A954:("Math3D_PointRelativeToCubeFaces",),
0x8017AA0C:("Math3D_PointRelativeToCubeEdges",),
0x8017ABBC:("Math3D_PointRelativeToCubeVertices",),
0x8017AD38:("Math3D_LineVsCube",),
0x8017B68C:("func_8017B68C",),
0x8017B7F8:("func_8017B7F8",),
0x8017B884:("Math3D_UnitNormalVector",),
0x8017B998:("Math3D_SignedDistanceFromPlane",),
0x8017B9D8:("func_8017B9D8",),
0x8017BA14:("Math3D_NormalizedDistanceFromPlane",),
0x8017BA4C:("Math3D_NormalizedSignedDistanceFromPlane",),
0x8017BAD0:("func_8017BAD0",),
0x8017BA14:("Math3D_UDistPlaneToPos",),
0x8017BA4C:("Math3D_DistPlaneToPos",),
0x8017BAD0:("Math3D_TriChkPointParaYDist",),
0x8017BD98:("func_8017BD98",),
0x8017BDE0:("func_8017BDE0",),
0x8017BE30:("func_8017BE30",),
0x8017BEE0:("func_8017BEE0",),
0x8017BE30:("Math3D_TriChkPointParaYIntersectDist",),
0x8017BEE0:("Math3D_TriChkPointParaYIntersectInsideTri",),
0x8017BF8C:("func_8017BF8C",),
0x8017C008:("func_8017C008",),
0x8017C008:("Math3D_TriChkLineSegParaYIntersect",),
0x8017C17C:("func_8017C17C",),
0x8017C1F0:("func_8017C1F0",),
0x8017C494:("func_8017C494",),
0x8017C540:("func_8017C540",),
0x8017C494:("Math3D_TriChkPointParaYIntersectInsideTri2",),
0x8017C540:("Math3D_TriChkPointParaXDist",),
0x8017C808:("func_8017C808",),
0x8017C850:("func_8017C850",),
0x8017C850:("Math3D_TriChkPointParaXIntersect",),
0x8017C904:("func_8017C904",),
0x8017C980:("func_8017C980",),
0x8017C980:("Math3D_TriChkLineSegParaXIntersect",),
0x8017CB08:("func_8017CB08",),
0x8017CB7C:("func_8017CB7C",),
0x8017CB7C:("Math3D_TriChkLineSegParaZDist",),
0x8017CEA8:("func_8017CEA8",),
0x8017CEF0:("func_8017CEF0",),
0x8017CEF0:("Math3D_TriChkPointParaZIntersect",),
0x8017CFA4:("func_8017CFA4",),
0x8017D020:("func_8017D020",),
0x8017D020:("Math3D_TriChkLineSegParaZIntersect",),
0x8017D1AC:("func_8017D1AC",),
0x8017D220:("func_8017D220",),
0x8017D2FC:("func_8017D2FC",),
@ -3329,14 +3329,14 @@
0x8017D814:("func_8017D814",),
0x8017D91C:("func_8017D91C",),
0x8017DA24:("func_8017DA24",),
0x8017DB2C:("Math3D_ColSphereLineSeg",),
0x8017DB2C:("Math3D_LineVsSph",),
0x8017DD34:("func_8017DD34",),
0x8017DE74:("Math3D_ColSphereTri",),
0x8017E294:("func_8017E294",),
0x8017E350:("func_8017E350",),
0x8017ED20:("Math3D_ColCylinderTri",),
0x8017F1A0:("func_8017F1A0",),
0x8017F1C0:("Math3D_ColSphereSphere",),
0x8017F1C0:("Math3D_SphVsSph",),
0x8017F1E0:("Math3D_ColSphereSphereIntersect",),
0x8017F200:("Math3D_ColSphereSphereIntersectAndDistance",),
0x8017F2CC:("Math3D_ColSphereCylinderDistance",),
@ -3344,9 +3344,9 @@
0x8017F45C:("Math3D_ColCylinderCylinderAmount",),
0x8017F47C:("Math3D_ColCylinderCylinderAmountAndDistance",),
0x8017F64C:("Math3d_ColTriTri",),
0x8017F9C0:("func_8017F9C0",),
0x8017FA34:("func_8017FA34",),
0x8017FAA8:("func_8017FAA8",),
0x8017F9C0:("Math3D_XZInSphere",),
0x8017FA34:("Math3D_XYInSphere",),
0x8017FAA8:("Math3D_YZInSphere",),
0x8017FB1C:("func_8017FB1C",),
0x8017FD44:("func_8017FD44",),
0x8017FEB0:("Math_GetAtan2Tbl",),

39
tools/disasm/variables.txt
View File

@ -453,14 +453,8 @@
0x801AEFC0:("D_801AEFC0","UNK_TYPE1","",0x1),
0x801AEFD0:("gActorOverlayTable","ActorOverlay","[ACTOR_ID_MAX]",0x5640),
0x801B4610:("gMaxActorId","s32","",0x4),
0x801B4620:("D_801B4620","u32","[32]",0x80),
0x801B46A0:("D_801B46A0","u16","[16]",0x20),
0x801B46C0:("D_801B46C0","u8","[16]",0x10),
0x801B46D0:("bgSpecialSceneParamsDefault","s16","[1]",0x2),
0x801B46D2:("D_801B46D2","UNK_TYPE1","",0x1),
0x801B46D4:("bgSpecialSceneMaxMemory","BgSpecialSceneMaxMemory","[1]",0x8),
0x801B46DC:("bgSpecialSceneMeshSubdivisions","BgSpecialSceneMeshSubdivision","[3]",0x24),
0x801B4700:("bgSpecialSceneMaxObjects","BgSpecialSceneMaxObjects","[1]",0x8),
0x801B46DC:("sSceneSubdivisionList","BgCheckSceneSubdivisionEntry","[3]",0x24),
0x801B4700:("sCustomDynapolyMem","BgSpecialSceneMaxObjects","[1]",0x8),
0x801B4708:("D_801B4708","UNK_TYPE1","",0x1),
0x801B4710:("D_801B4710","UNK_TYPE1","",0x1),
0x801B4738:("D_801B4738","UNK_TYPE1","",0x1),
@ -3924,34 +3918,17 @@
0x801ED940:("D_801ED940","FaultAddrConvClient","",0xc),
0x801ED950:("D_801ED950","char","[80]",0x50),
0x801ED9A0:("D_801ED9A0","char","[80]",0x50),
0x801ED9F0:("D_801ED9F0","Vec3f","",0xc),
0x801ED9FC:("D_801ED9FC","Vec3f","",0xc),
0x801EDA08:("D_801EDA08","Vec3f","",0xc),
0x801EDA18:("D_801EDA18","Vec3f","",0xc),
0x801EDA24:("D_801EDA24","Vec3f","",0xc),
0x801EDA30:("D_801EDA30","Vec3f","",0xc),
0x801ED9F0:("D_801ED9F0","Vec3f","[3]",0x24),
0x801EDA18:("D_801EDA18","Vec3f","[3]",0x24),
0x801EDA40:("D_801EDA40","MtxF","",0x40),
0x801EDA80:("D_801EDA80","Vec3f","",0xc),
0x801EDA8C:("D_801EDA8C","Vec3f","",0xc),
0x801EDA98:("D_801EDA98","Vec3f","",0xc),
0x801EDA80:("D_801EDA80","Vec3f","[3]",0x24),
0x801EDAA8:("D_801EDAA8","char","[80]",0x50),
0x801EDAF8:("D_801EDAF8","char","[80]",0x50),
0x801EDB48:("D_801EDB48","Vec3f","",0xc),
0x801EDB54:("D_801EDB54","Vec3f","",0xc),
0x801EDB60:("D_801EDB60","Vec3f","",0xc),
0x801EDB70:("D_801EDB70","Vec3f","",0xc),
0x801EDB7C:("D_801EDB7C","Vec3f","",0xc),
0x801EDB88:("D_801EDB88","Vec3f","",0xc),
0x801EDB98:("D_801EDB98","f32","",0x4),
0x801EDB9C:("D_801EDB9C","f32","",0x4),
0x801EDBA0:("D_801EDBA0","f32","",0x4),
0x801EDBA4:("D_801EDBA4","UNK_TYPE1","",0x1),
0x801EDB48:("D_801EDB48","Vec3f","[3]",0x24),
0x801EDB70:("D_801EDB70","Vec3f","[3]",0x24),
0x801EDB98:("D_801EDB98","Plane","",0x10),
0x801EDBA8:("D_801EDBA8","Sphere16","",0x8),
0x801EDBB0:("D_801EDBB0","TriNorm","",0x34),
0x801EDBD4:("D_801EDBD4","UNK_TYPE1","",0x1),
0x801EDBD8:("D_801EDBD8","UNK_TYPE1","",0x1),
0x801EDBDC:("D_801EDBDC","UNK_TYPE1","",0x1),
0x801EDBE0:("D_801EDBE0","UNK_TYPE1","",0x1),
0x801EDBF0:("D_801EDBF0","s16","",0x2),
0x801EDBF4:("D_801EDBF4","UNK_TYPE1","",0x1),
0x801EDBF8:("D_801EDBF8","UNK_TYPE1","",0x1),