From 05655b74985db8c749bf72cf65d3edeacfa8b897 Mon Sep 17 00:00:00 2001 From: Colin Miller Date: Sun, 13 Jul 2025 23:23:56 -0400 Subject: [PATCH 01/13] ported zNPCSupport code, zNPCTypeCommon --- src/SB/Core/gc/iCollide.h | 3 +- src/SB/Core/x/xCollide.h | 14 + src/SB/Core/x/xDraw.h | 3 + src/SB/Core/x/xMath.h | 2 + src/SB/Core/x/xSpline.h | 7 +- src/SB/Game/zMovePoint.h | 5 + src/SB/Game/zNPCFXCinematic.cpp | 19 +- src/SB/Game/zNPCFXCinematic.h | 11 +- src/SB/Game/zNPCMessenger.h | 6 +- src/SB/Game/zNPCSupport.cpp | 814 ++++++++- src/SB/Game/zNPCSupport.h | 9 +- src/SB/Game/zNPCTypeCommon.cpp | 2787 ++++++++++++++++++++++++++++++- src/SB/Game/zNPCTypeCommon.h | 57 +- 13 files changed, 3568 insertions(+), 169 deletions(-) diff --git a/src/SB/Core/gc/iCollide.h b/src/SB/Core/gc/iCollide.h index 41f9af95b..bff1746a9 100644 --- a/src/SB/Core/gc/iCollide.h +++ b/src/SB/Core/gc/iCollide.h @@ -10,8 +10,9 @@ void iBoxForModelLocal(xBox* o, const xModelInstance* m); void iBoxForModel(xBox* o, const xModelInstance* m); S32 iSphereHitsEnv3(const xSphere* b, const xEnv* env, xCollis* colls, U8 ncolls, F32 sth); S32 iSphereHitsModel3(const xSphere* b, const xModelInstance* m, xCollis* colls, U8 ncolls, - F32 sth); + F32 sth); U32 iRayHitsModel(const xRay3* r, const xModelInstance* m, xCollis* coll); +void iSphereForModel(xSphere* o, const xModelInstance* m); void iCollideInit(xScene* sc); #endif diff --git a/src/SB/Core/x/xCollide.h b/src/SB/Core/x/xCollide.h index 331393247..17655cd6c 100644 --- a/src/SB/Core/x/xCollide.h +++ b/src/SB/Core/x/xCollide.h @@ -6,6 +6,20 @@ #include "xQuickCull.h" #include "iMath3.h" +#define k_HIT_IT ((U32)(1 << 0)) +#define k_HIT_0x2 ((U32)(1 << 1)) +#define k_HIT_0x4 ((U32)(1 << 2)) +#define k_HIT_0x8 ((U32)(1 << 3)) +#define k_HIT_0x10 ((U32)(1 << 4)) +#define k_HIT_0x100 ((U32)(1 << 8)) +#define k_HIT_0x200 ((U32)(1 << 9)) +#define k_HIT_0x400 ((U32)(1 << 10)) +#define k_HIT_0x800 ((U32)(1 << 11)) +#define k_HIT_0xF00 (k_HIT_0x100 | k_HIT_0x200 | k_HIT_0x400 | k_HIT_0x800) +#define k_HIT_CALC_HDNG ((U32)(1 << 12)) +#define k_HIT_CALC_TRI ((U32)(1 << 13)) +#define k_HIT_0x20000 ((U32)(1 << 17)) + struct xModelInstance; struct xCollis diff --git a/src/SB/Core/x/xDraw.h b/src/SB/Core/x/xDraw.h index 6e91c87c5..f3c46b9b3 100644 --- a/src/SB/Core/x/xDraw.h +++ b/src/SB/Core/x/xDraw.h @@ -5,6 +5,9 @@ #include "xMath3.h" void xDrawSetColor(iColor_tag); +inline void xDrawLine(const xVec3* a, const xVec3* b) +{ +} void xDrawSphere2(const xSphere*, U32); void xDrawOBB(const xBox*, const xMat4x3*); void xDrawBox(const xBox*); diff --git a/src/SB/Core/x/xMath.h b/src/SB/Core/x/xMath.h index 8f1ca7f21..669c5de79 100644 --- a/src/SB/Core/x/xMath.h +++ b/src/SB/Core/x/xMath.h @@ -9,6 +9,8 @@ #define MIN(a, b) (((a) < (b)) ? (a) : (b)) #define xabs(x) iabs(x) +#define xeq(a, b, e) (xabs((a) - (b)) <= (e)) + #define CLAMP(x, a, b) (MAX((a), MIN((x), (b)))) #define SQR(x) ((x) * (x)) diff --git a/src/SB/Core/x/xSpline.h b/src/SB/Core/x/xSpline.h index 50a103e4a..3bf649f8d 100644 --- a/src/SB/Core/x/xSpline.h +++ b/src/SB/Core/x/xSpline.h @@ -32,6 +32,11 @@ struct xSpline3 }; void xSpline3_ArcInit(xSpline3* spl, U32 sample); -xSpline3* xSpline3_Bezier(xVec3* points, F32* time, U32 numpoints, U32 numalloc, xVec3* p1, xVec3* p2); +xSpline3* xSpline3_Bezier(xVec3* points, F32* time, U32 numpoints, U32 numalloc, xVec3* p1, + xVec3* p2); +inline F32 xSpline3_ArcTotal(xSpline3* spl) +{ + return spl->arcLength[spl->N * spl->arcSample - 1]; +} #endif diff --git a/src/SB/Game/zMovePoint.h b/src/SB/Game/zMovePoint.h index 3b45bd91e..5cd6b372e 100644 --- a/src/SB/Game/zMovePoint.h +++ b/src/SB/Game/zMovePoint.h @@ -23,6 +23,11 @@ struct zMovePoint : xMovePoint } U32 NumNodes(); S32 IsOn(); + + S32 HasSpline() + { + return spl != NULL; + } }; zMovePoint* zMovePoint_GetMemPool(S32 cnt); diff --git a/src/SB/Game/zNPCFXCinematic.cpp b/src/SB/Game/zNPCFXCinematic.cpp index 55d859e50..a5431480f 100644 --- a/src/SB/Game/zNPCFXCinematic.cpp +++ b/src/SB/Game/zNPCFXCinematic.cpp @@ -438,6 +438,14 @@ void NCIN_Par_CIN_PLATFORM_JETS_Upd(const zCutsceneMgr*, NCINEntry* fxrec, S32 p fxrec->pos_B[0] = 5.0f; } +void NCINBeNosey::CanRenderNow() +{ + zCutsceneMgr* csnmgr; + NCINEntry* fxtab; + NCINEntry* nextrec; + NCINEntry* fxrec; +} + void NCIN_Generic_Upd(const zCutsceneMgr*, NCINEntry* fxrec, S32 param) { if (param != 0) @@ -473,7 +481,8 @@ void NCIN_BubSlam(const zCutsceneMgr*, NCINEntry* fxrec, S32 param) } } -void NCIN_BubTrailBone_AR(const zCutsceneMgr*, NCINEntry* fxrec, RpAtomic*, RwMatrixTag*, U32 num_1, U32 num_2) +void NCIN_BubTrailBone_AR(const zCutsceneMgr*, NCINEntry* fxrec, RpAtomic*, RwMatrixTag*, U32 num_1, + U32 num_2) { S32 ifx = fxrec->pos_A[1].x; S32 ify = fxrec->pos_A[1].y; @@ -690,6 +699,14 @@ void NCIN_HazTTSteam_AR(const zCutsceneMgr* cutsceneMgr, NCINEntry* fxrec, RpAto { } +void NCIN_ArfDogBoom(const zCutsceneMgr*, NCINEntry*, S32) +{ +} + +void NCIN_ShieldPop(const zCutsceneMgr*, NCINEntry*, S32) +{ +} + void clamp_bone_index(NCINEntry*, RpAtomic*) { } diff --git a/src/SB/Game/zNPCFXCinematic.h b/src/SB/Game/zNPCFXCinematic.h index 361788736..8d4172c7c 100644 --- a/src/SB/Game/zNPCFXCinematic.h +++ b/src/SB/Game/zNPCFXCinematic.h @@ -11,14 +11,12 @@ #include "zShrapnel.h" #include "rwcore.h" - void zNPCFXStartup(); void zNPCFXShutdown(); S32 zNPCFXCutscenePrep(const xScene*, F32, const zCutsceneMgr* csnmgr); void zNPCFXCutscene(const xScene*, F32, const zCutsceneMgr* csnmgr); void zNPCFXCutsceneDone(const xScene*, F32, const zCutsceneMgr* csnmgr); - struct NCINLyt { zLightning* lyt_zap; @@ -200,4 +198,13 @@ struct NPCCone void RadiusSet(F32); }; +struct NCINBeNosey : XCSNNosey +{ + zCutsceneMgr* use_csnmgr; + NCINEntry* use_fxtab; + + void UpdatedAnimated(RpAtomic* model, RwMatrixTag* animMat, U32 animIndex, U32 dataIndex); + void CanRenderNow(); +}; + #endif diff --git a/src/SB/Game/zNPCMessenger.h b/src/SB/Game/zNPCMessenger.h index 9f73d480e..0d3d80f36 100644 --- a/src/SB/Game/zNPCMessenger.h +++ b/src/SB/Game/zNPCMessenger.h @@ -8,10 +8,12 @@ void zNPCMsg_SceneReset(); void zNPCMsg_ScenePrepare(); void zNPCMsg_Startup(); void zNPCMsg_Shutdown(); -void zNPCMsg_AreaNotify(zNPCCommon* sender, en_NPC_MSG_ID msgid, F32 rad, S32 filter, - en_NPCTYPES toNPCType); +// void zNPCMsg_AreaNotify(zNPCCommon* sender, en_NPC_MSG_ID msgid, F32 rad, S32 filter, +// en_NPCTYPES toNPCType); void zNPCMsg_Timestep(xScene* xscn, F32 dt); +struct NPCMsg; + struct NPCPSClt { // total size: 0x10 diff --git a/src/SB/Game/zNPCSupport.cpp b/src/SB/Game/zNPCSupport.cpp index 0c04cd95e..29dfb2eec 100644 --- a/src/SB/Game/zNPCSupport.cpp +++ b/src/SB/Game/zNPCSupport.cpp @@ -8,18 +8,33 @@ #include "zNPCHazard.h" #include "zNPCGlyph.h" #include "zNPCSupplement.h" +#include "zNPCMgr.h" +#include "zNPCTypeRobot.h" +#include "zNPCFXCinematic.h" #include "xMathInlines.h" #include "xMath3.h" #include "xUtil.h" #include "xBound.h" +#include "xQuickCull.h" +#include "xCollide.h" + +#define MAX_FIREWORK 32 NPCWidget g_npc_widgets[1] = {}; static U32 g_hash_uiwidgets[1] = { 0 }; static char* g_strz_uiwidgets[1] = { "MNU4 NPCTALK" }; + +static U32 sNPCSndFx[eNPCSnd_Total] = {}; +static U32 sNPCSndID[eNPCSnd_Total] = {}; +static F32 sNPCSndFxVolume[eNPCSnd_Total] = {}; + S32 g_pc_playerInvisible; static Firework g_fireworks[32]; +F32 Firework::acc_thrust = 15.0f; +F32 Firework::acc_gravity = -10.0f; + void NPCSupport_Startup() { zNPCHazard_Startup(); @@ -83,7 +98,10 @@ void NPCSupport_Timestep(F32 dt) void NPCWidget_Startup() { - g_hash_uiwidgets[0] = xStrHash((const char*)g_strz_uiwidgets); + for (S32 i = 0; i < NPC_WIDGE_NOMORE; i++) + { + g_hash_uiwidgets[i] = xStrHash(g_strz_uiwidgets[i]); + } } void NPCWidget_Shutdown() @@ -108,7 +126,7 @@ void NPCWidget::Reset() { } -U32 NPCWidget::On(const zNPCCommon* npc, int theman) +S32 NPCWidget::On(const zNPCCommon* npc, S32 theman) { if ((!theman && !NPCIsTheLocker(npc)) && (((S32)IsLocked()) || (!Lock(npc)))) { @@ -128,6 +146,23 @@ U32 NPCWidget::On(const zNPCCommon* npc, int theman) return 1; } +S32 NPCWidget::Off(const zNPCCommon* npc, S32 theman) +{ + if (!theman && !this->NPCIsTheLocker(npc)) + { + return 0; + } + + if (npc) + { + this->Unlock(npc); + } + + zEntEvent(this->base_widge, eEventInvisible); + zEntEvent(this->base_widge, eEventUIFocusOff_Unselect); + return 1; +} + S32 NPCWidget::Unlock(const zNPCCommon* npc) { if (npc_ownerlock == NULL) @@ -192,7 +227,8 @@ NPCWidget* NPCWidget_Find(en_NPC_UI_WIDGETS which) void NPCWidget::Init(en_NPC_UI_WIDGETS which) { - base_widge = zSceneFindObject(g_hash_uiwidgets[idxID = which]); + idxID = which; + base_widge = zSceneFindObject(g_hash_uiwidgets[idxID]); } void NPCTarget::TargetSet(xEnt* ent, int b) @@ -217,6 +253,322 @@ void NPCTarget::TargetClear() typ_target = NPC_TGT_NONE; } +S32 NPCTarget::FindNearest(S32 flg_consider, xBase* skipme, xVec3* from, F32 dst_max) +//NONMATCH("https://decomp.me/scratch/wWBRW") +{ + S32 found = 0; + st_XORDEREDARRAY* npclist; + F32 ds2_best; + zNPCCommon *npc, *npc_best; + xVec3 vec = {}; + F32 fv; + S32 i, ntyp; + + npc_best = NULL; + ds2_best = (dst_max < 0.0f) ? HUGE : SQ(dst_max); + + if (flg_consider & 0x1) + { + this->TargetSet(&globals.player.ent, 1); + + if (from) + { + xVec3Sub(&vec, xEntGetPos(&globals.player.ent), from); + ds2_best = xVec3Length2(&vec); + } + } + + if (from && (flg_consider & 0x1E)) + { + npclist = zNPCMgr_GetNPCList(); + + for (i = 0; i < npclist->cnt; i++) + { + npc = (zNPCCommon*)npclist->list[i]; + ntyp = npc->SelfType(); + + if (npc == skipme) + continue; + + if (((ntyp & 0xFFFFFF00) != 'NTT\0' || (flg_consider & 0x4)) && + ((ntyp & 0xFFFFFF00) != 'NTR\0' || (flg_consider & 0x2)) && + ((ntyp & 0xFFFFFF00) != 'NTF\0' || (flg_consider & 0x8)) && + ((ntyp & 0xFFFFFF00) != 'NTA\0' || (flg_consider & 0x10))) + { + if (npc->IsAlive()) + { + xVec3Sub(&vec, xEntGetPos(npc), from); + if (flg_consider & 0x80) + { + vec.y = 0.0f; + } + + fv = xVec3Length2(&vec); + if (fv > ds2_best) + continue; + + ds2_best = fv; + npc_best = npc; + found = 1; + } + } + } + + if (found) + { + this->TargetSet(npc_best, 0); + } + } + + return found; +} + +S32 NPCTarget::InCylinder(xVec3* from, F32 rad, F32 hyt, F32 off) +{ + S32 inrange = 1; + + xVec3 vec = {}; + this->PosGet(&vec); + xVec3SubFrom(&vec, from); + + F32 upper = hyt + off; + F32 lower = upper - hyt; + + if (vec.y > upper) + { + inrange = 0; + } + else if (vec.y < lower) + { + inrange = 0; + } + else if (xVec3Length2(&vec) > SQ(rad)) + { + inrange = 0; + } + + return inrange; +} + +S32 NPCTarget::IsDead() +{ + S32 dead = 0; + + switch (this->typ_target) + { + case NPC_TGT_PLYR: + if (globals.player.Health < 1) + { + dead = 1; + } + break; + case NPC_TGT_ENT: + if (this->ent_target->baseType == eBaseTypeNPC) + { + if (!((zNPCCommon*)this->ent_target)->IsAlive()) + { + dead = 1; + } + } + break; + case NPC_TGT_BASE: + break; + } + + return dead; +} + +// void NPCLaser::Render(xVec3* pos_src, xVec3* pos_tgt) +// //NONMATCH("https://decomp.me/scratch/lNgTd") +// { +// xVec3 var_70; +// xVec3Copy(&var_70, pos_src); + +// xVec3 var_7C; +// xVec3Copy(&var_7C, pos_tgt); + +// xVec3 var_88; +// xVec3Sub(&var_88, &var_7C, &var_70); +// xVec3Normalize(&var_88, &var_88); + +// xVec3 var_94; +// xVec3Cross(&var_94, &globals.camera.mat.at, &var_88); + +// F32 f1 = xVec3Length2(&var_94); +// if (f1 < 0.00001f) +// { +// xVec3Copy(&var_94, &g_X3); +// } +// else +// { +// xVec3SMulBy(&var_94, 1.0f / xsqrt(f1)); +// } + +// xVec3 var_A0; +// xVec3Cross(&var_A0, &var_94, &var_88); + +// S32 i; + +// static RwIm3DVertex laser_vtxbuf[2][14]; +// RwIm3DVertex* vtx_horz = laser_vtxbuf[0]; +// RwIm3DVertex* vtx_vert = laser_vtxbuf[1]; + +// for (i = 0; i <= 6; i++) +// { +// F32 rat = (F32)i / 6.0f; +// F32 f29 = LERP(rat, this->radius[0], this->radius[1]); + +// xVec3 var_AC; +// var_AC.x = LERP(rat, var_70.x, var_7C.x); +// var_AC.y = LERP(rat, var_70.y, var_7C.y); +// var_AC.z = LERP(rat, var_70.z, var_7C.z); + +// U8 r22 = LERP(rat, this->rgba[0].red, this->rgba[1].red); +// U8 r23 = LERP(rat, this->rgba[0].green, this->rgba[1].green); +// U8 r24 = LERP(rat, this->rgba[0].blue, this->rgba[1].blue); +// U8 r25 = LERP(rat, this->rgba[0].alpha, this->rgba[1].alpha); + +// F32 u = 1.0f - rat + this->uv_base[0]; +// F32 v = 1.0f - rat + this->uv_base[1]; + +// while (u > 1.0f) +// u -= 1.0f; +// while (v > 1.0f) +// v -= 1.0f; + +// xVec3 var_B8; + +// xVec3SMul(&var_B8, &var_94, f29); +// xVec3AddTo(&var_B8, &var_AC); +// RwIm3DVertexSetPos(&vtx_horz[0], var_B8.x, var_B8.y, var_B8.z); +// RwIm3DVertexSetRGBA(&vtx_horz[0], r22, r23, r24, r25); +// RwIm3DVertexSetU(&vtx_horz[0], 0.0f); +// RwIm3DVertexSetV(&vtx_horz[0], v); + +// xVec3SMul(&var_B8, &var_94, -f29); +// xVec3AddTo(&var_B8, &var_AC); +// RwIm3DVertexSetPos(&vtx_horz[1], var_B8.x, var_B8.y, var_B8.z); +// RwIm3DVertexSetRGBA(&vtx_horz[1], r22, r23, r24, r25); +// RwIm3DVertexSetU(&vtx_horz[1], 1.0f); +// RwIm3DVertexSetV(&vtx_horz[1], v); + +// vtx_horz += 2; + +// xVec3SMul(&var_B8, &var_A0, f29); +// xVec3AddTo(&var_B8, &var_AC); +// RwIm3DVertexSetPos(&vtx_vert[0], var_B8.x, var_B8.y, var_B8.z); +// RwIm3DVertexSetRGBA(&vtx_vert[0], r22, r23, r24, r25); +// RwIm3DVertexSetU(&vtx_vert[0], 0.0f); +// RwIm3DVertexSetV(&vtx_vert[0], v); + +// xVec3SMul(&var_B8, &var_A0, -f29); +// xVec3AddTo(&var_B8, &var_AC); +// RwIm3DVertexSetPos(&vtx_vert[1], var_B8.x, var_B8.y, var_B8.z); +// RwIm3DVertexSetRGBA(&vtx_vert[1], r22, r23, r24, r25); +// RwIm3DVertexSetU(&vtx_vert[1], 1.0f); +// RwIm3DVertexSetV(&vtx_vert[1], v); + +// vtx_vert += 2; +// } + +// SDRenderState old_rendstat = zRenderStateCurrent(); +// if (old_rendstat == SDRS_Unknown) +// { +// old_rendstat = SDRS_Default; +// } + +// zRenderState(SDRS_NPCVisual); + +// RwRenderStateSet(rwRENDERSTATETEXTURERASTER, (void*)this->rast_laser); +// RwIm3DTransform(laser_vtxbuf[0], 14, NULL, +// rwIM3D_VERTEXXYZ | rwIM3D_VERTEXRGBA | rwIM3D_VERTEXUV); +// RwIm3DRenderPrimitive(rwPRIMTYPETRISTRIP); +// RwIm3DEnd(); + +// RwRenderStateSet(rwRENDERSTATETEXTURERASTER, (void*)this->rast_laser); +// RwIm3DTransform(laser_vtxbuf[1], 14, NULL, +// rwIM3D_VERTEXXYZ | rwIM3D_VERTEXRGBA | rwIM3D_VERTEXUV); +// RwIm3DRenderPrimitive(rwPRIMTYPETRISTRIP); +// RwIm3DEnd(); + +// zRenderState(old_rendstat); +// } + +// void NPCCone::RenderCone(xVec3* pos_tiptop, xVec3* pos_botcenter) +// //NONMATCH("https://decomp.me/scratch/G9pbs") +// { +// RwRGBA rgba_top = this->rgba_top; +// RwRGBA rgba_bot = this->rgba_bot; +// xVec3 pos_top = *pos_tiptop; +// xVec3 pos_bot = *pos_botcenter; +// F32 f29 = this->uv_tip[0] + 0.5f * this->uv_slice[0]; +// F32 f28 = this->uv_tip[1]; +// F32 f31 = this->uv_tip[0] + this->uv_slice[0]; +// F32 f30 = this->uv_tip[1] + this->uv_slice[1]; + +// void* mem = xMemPushTemp(10 * sizeof(RwIm3DVertex)); +// if (!mem) +// { +// return; +// } + +// memset(mem, 0, 10 * sizeof(RwIm3DVertex)); + +// RwIm3DVertex* vert_list = (RwIm3DVertex*)mem; +// RwIm3DVertex* vtx = vert_list + 1; + +// RwIm3DVertexSetPos(&vert_list[0], pos_top.x, pos_top.y, pos_top.z); +// RwIm3DVertexSetRGBA(&vert_list[0], rgba_top.red, rgba_top.green, rgba_top.blue, rgba_top.alpha); +// RwIm3DVertexSetU(&vert_list[0], f29); +// RwIm3DVertexSetV(&vert_list[0], f28); + +// for (S32 i = 0; i < 8; i++) +// { +// F32 ang_seg = i * PI / 4; +// F32 f29 = isin(ang_seg); +// F32 f1 = icos(ang_seg); + +// xVec3 var_A0; +// var_A0.x = f29; +// var_A0.y = 0.0f; +// var_A0.z = f1; +// var_A0 *= this->rad_cone; +// var_A0 += pos_bot; + +// RwIm3DVertexSetPos(vtx, var_A0.x, var_A0.y, var_A0.z); +// RwIm3DVertexSetRGBA(vtx, rgba_bot.red, rgba_bot.green, rgba_bot.blue, rgba_bot.alpha); + +// F32 f0 = 1 / 8.0f * i; + +// RwIm3DVertexSetU(vtx, f31 + f0); +// RwIm3DVertexSetV(vtx, f30); + +// vtx++; +// } + +// *vtx = vert_list[1]; +// RwIm3DVertexSetU(vtx, f31 + this->uv_slice[0]); +// RwIm3DVertexSetV(vtx, f30); + +// SDRenderState old_rendstat = zRenderStateCurrent(); +// if (old_rendstat == SDRS_Unknown) +// { +// old_rendstat = SDRS_Default; +// } + +// zRenderState(SDRS_NPCVisual); + +// RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE); +// RwRenderStateSet(rwRENDERSTATETEXTURERASTER, (void*)this->rast_cone); +// RwIm3DTransform(vert_list, 10, NULL, rwIM3D_VERTEXXYZ | rwIM3D_VERTEXRGBA | rwIM3D_VERTEXUV); +// RwIm3DRenderPrimitive(rwPRIMTYPETRIFAN); +// RwIm3DEnd(); + +// zRenderState(old_rendstat); + +// xMemPopTemp(mem); +// } + void NPCBlinker::Reset() { tmr_uvcell = -1.0f; @@ -270,7 +622,45 @@ void Firework::Cleanup() { } -void NPAR_EmitFWExhaust(xVec3* pos, xVec3* vel); +void NPAR_EmitFWExhaust(xVec3* pos, const xVec3* vel); + +void Firework::Update(F32 dt) +{ + switch (this->fwstate) + { + case FW_STAT_FLIGHT: + this->FlyFlyFly(dt); + if (this->tmr_remain < 0.0f) + { + this->fwstate = FW_STAT_BOOM; + } + break; + case FW_STAT_BOOM: + this->Detonate(); + this->fwstate = FW_STAT_DONE; + break; + case FW_STAT_DONE: + break; + } + + this->tmr_remain = MAX(-1.0f, this->tmr_remain - dt); +} + +void Firework::FlyFlyFly(F32 dt) //NONMATCH("https://decomp.me/scratch/6hPC3") +{ + F32 pam_life = 1.0f - CLAMP(this->tmr_remain / this->tym_lifespan, 0.0f, 1.0f); + if (pam_life < 0.75f) + { + xVec3 dir_trav = this->vel; + dir_trav.normalize(); + + this->vel += dir_trav * (Firework::acc_thrust * dt); + } + + this->vel += g_NY3 * (Firework::acc_gravity * dt); + + NPAR_EmitFWExhaust(&this->pos, &g_O3); +} void Firework::Detonate() { @@ -291,7 +681,129 @@ void NPCC_dir_toXZAng(const xVec3* vec) void NPCC_aimMiss(xVec3* dir_aim, xVec3* pos_src, xVec3* pos_tgt, F32 dst_miss, xVec3* pos_miss) { - NPCC_aimVary(dir_aim, pos_src, pos_tgt, dst_miss, 8, pos_miss); + NPCC_aimVary(dir_aim, pos_src, pos_tgt, dst_miss, 8, pos_miss); +} + +F32 NPCC_aimVary(xVec3* dir_aim, xVec3* pos_src, xVec3* pos_tgt, F32 dst_vary, S32 flg_vary, + xVec3* pos_aimPoint) //NONMATCH("https://decomp.me/scratch/D1gIj") +{ + F32 dst_toFake = 0.0f; + xVec3 dir_left = {}; + xVec3 dir_toFake = {}; + xVec3 dir_toReal = {}; + xVec3 vec_offset = {}; + xVec3 pos_tgtFake = {}; + + xVec3Sub(&dir_toReal, pos_tgt, pos_src); + + if (flg_vary & 0x10) + { + dir_toReal.y = 0.0f; + } + + F32 mag_vary = xVec3Length(&dir_toReal); + if (mag_vary < 0.001f) + { + if (mag_vary > 0.0f) + { + xVec3SMulBy(&dir_toReal, 100000.0f); + xVec3Normalize(&dir_toReal, &dir_toReal); + } + else + { + xVec3Copy(dir_aim, &g_X3); + } + + if (pos_aimPoint) + { + xVec3Copy(pos_aimPoint, pos_tgt); + } + + return mag_vary; + } + + xVec3SMulBy(&dir_toReal, 1.0f / mag_vary); + xVec3Cross(&dir_left, &g_Y3, &dir_toReal); + + F32 mag_updown; + if (flg_vary & 0x8) + { + mag_updown = dst_vary; + } + else + { + mag_updown = 2.0f * (xurand() - 0.5f) * dst_vary; + + F32 fv; + if ((flg_vary & 0x1) && (flg_vary & 0x2)) + { + fv = 2.0f * (xurand() - 0.5f); + } + else if (flg_vary == 0x1) + { + fv = xurand(); + } + else if (flg_vary == 0x2) + { + fv = -xurand(); + } + else + { + fv = 0.0f; + } + + dst_toFake = fv * dst_vary; + } + + xVec3AddScaled(&vec_offset, &dir_left, mag_updown); + xVec3AddScaled(&vec_offset, &g_Y3, dst_toFake); + xVec3Add(&pos_tgtFake, pos_tgt, &vec_offset); + xVec3Sub(&dir_toFake, &pos_tgtFake, pos_src); + + F32 f31 = xVec3Normalize(&dir_toFake, dir_aim); + + if (pos_aimPoint) + { + xVec3Copy(pos_aimPoint, &pos_tgtFake); + } + + return (flg_vary & 0x4) ? f31 : mag_vary; +} + +S32 NPCC_chk_hitEnt(xEnt* tgt, xBound* bnd, + xCollis* collide) //NONMATCH("https://decomp.me/scratch/Bf1rk") +{ + S32 hittgt = 0; + xCollis* colrec; + xCollis lcl_collide = {}; + + colrec = collide ? collide : &lcl_collide; + colrec->optr = tgt; + colrec->oid = tgt->id; + + if (collide) + { + colrec->flags = ((U32)(1 << 9)) | ((U32)(1 << 12)); + } + else + { + colrec->flags = 0; + } + + xQuickCullForEverything(&bnd->qcd); + xBoundHitsBound(bnd, &tgt->bound, colrec); + + if (colrec->flags & ((U32)(1 << 0))) + { + hittgt = 1; + } + + return hittgt; +} + +S32 NPCC_chk_hitPlyr(xBound* bnd, xCollis* collide) +{ + return NPCC_chk_hitEnt(&globals.player.ent, bnd, collide); } void Firework_SceneReset(int param_1) @@ -370,8 +882,82 @@ RwRaster* NPCC_FindRWRaster(RwTexture* txtr) return NULL; } -void zNPC_SNDInit() +void NPCC_GenSmooth(xVec3** pos_base, + xVec3** pos_mid) //WIP NONMATCH("https://decomp.me/scratch/1MplX") +{ + static F32 prepute[4][4]; + static const F32 yews[4] = { 0.25f, 0.5f, 0.75f, 1.0f }; + static S32 init = 0; + + S32 i; + + if (!init) + { + init = 1; + + for (i = 0; i < 4; i++) + { + F32 u = yews[i]; + F32 u2 = u * u; + F32 u3 = u * u2; + + prepute[i][0] = u2 + -0.5f * u3 + -0.5f * u; + prepute[i][1] = -2.5f * u2 + 1.5f * u3 + 1.0f; + prepute[i][2] = 2.0f * u2 + -1.5f * u3 + 0.5f * u; + prepute[i][3] = -0.5f * u2 + 0.5f * u3; + } + } + + for (i = 0; i < 4; i++) + { + xVec3SMul(pos_mid[i], pos_base[0], prepute[i][0]); + xVec3AddScaled(pos_mid[i], pos_base[1], prepute[i][1]); + xVec3AddScaled(pos_mid[i], pos_base[2], prepute[i][2]); + xVec3AddScaled(pos_mid[i], pos_base[3], prepute[i][3]); + } +} + +void zNPC_SNDInit() //NONMATCH("https://decomp.me/scratch/VlDh8") { + sNPCSndID[eNPCSnd_GloveAttack] = 0; + sNPCSndID[eNPCSnd_SleepyAttack] = 0; + sNPCSndID[eNPCSnd_TubeAttack] = 0; + sNPCSndID[eNPCSnd_FodBzztAttack] = 0; + sNPCSndID[eNPCSnd_JellyfishAttack] = 0; + + sNPCSndFxVolume[eNPCSnd_GloveAttack] = 0.77f; + sNPCSndFxVolume[eNPCSnd_SleepyAttack] = 0.77f; + sNPCSndFxVolume[eNPCSnd_TubeAttack] = 0.77f; + sNPCSndFxVolume[eNPCSnd_FodBzztAttack] = 0.77f; + sNPCSndFxVolume[eNPCSnd_JellyfishAttack] = 0.77f; + + sNPCSndFx[eNPCSnd_GloveAttack] = xStrHash("Glove_hover_loop"); + sNPCSndFx[eNPCSnd_SleepyAttack] = xStrHash("ST_hit2_loop"); + sNPCSndFx[eNPCSnd_TubeAttack] = xStrHash("Tube_attack21_loop"); + sNPCSndFx[eNPCSnd_FodBzztAttack] = xStrHash("FodBzzt_attack_loop"); + sNPCSndFx[eNPCSnd_JellyfishAttack] = xStrHash("Jellyfish_zap_loop"); +} + +void zNPC_SNDPlay3D(_tageNPCSnd snd, xEnt* ent) +{ + if (globals.cmgr) + return; + if (sNPCSndID[snd] != 0) + return; + if (sNPCSndFx[snd] == 0) + return; + + sNPCSndID[snd] = xSndPlay3D(sNPCSndFx[snd], sNPCSndFxVolume[snd], 0.0f, 0x80, 0, ent, 2.0f, + 15.0f, SND_CAT_GAME, 0.0f); +} + +void zNPC_SNDStop(_tageNPCSnd snd) +{ + if (sNPCSndFx[snd] == 0) + return; + + xSndStop(sNPCSndID[snd]); + sNPCSndID[snd] = 0; } U32 NPCC_LineHitsBound(xVec3* param_1, xVec3* param_2, xBound* param_3, xCollis* param_4) @@ -384,7 +970,7 @@ U32 NPCC_LineHitsBound(xVec3* param_1, xVec3* param_2, xBound* param_3, xCollis* if (param_4 != NULL) { - colrec = (xCollis *)param_4; + colrec = (xCollis*)param_4; } xVec3Sub(&vec, param_2, param_1); len = xVec3Length(&vec); @@ -407,74 +993,74 @@ S32 NPCC_bnd_ofBase(xBase* tgt, xBound* bnd) { S32 retval = 1; - switch(tgt->baseType) - { - case eBaseTypeCamera: - case eBaseTypeDoor: - case eBaseTypeVolume: - case eBaseTypeEGenerator: - retval = 0; - break; - case eBaseTypePlayer: - case eBaseTypePickup: - case eBaseTypePlatform: - case eBaseTypeStatic: - case eBaseTypeDynamic: - case eBaseTypeBubble: - case eBaseTypePendulum: - case eBaseTypeHangable: - case eBaseTypeButton: - case eBaseTypeProjectile: - case eBaseTypeDestructObj: - case eBaseTypeNPC: - case eBaseTypeBoulder: - *bnd = *(xBound*)((int)tgt + 0x64); - break; - default: - retval = 0; - break; - case eBaseTypeCruiseBubble: - break; + switch (tgt->baseType) + { + case eBaseTypeCamera: + case eBaseTypeDoor: + case eBaseTypeVolume: + case eBaseTypeEGenerator: + retval = 0; + break; + case eBaseTypePlayer: + case eBaseTypePickup: + case eBaseTypePlatform: + case eBaseTypeStatic: + case eBaseTypeDynamic: + case eBaseTypeBubble: + case eBaseTypePendulum: + case eBaseTypeHangable: + case eBaseTypeButton: + case eBaseTypeProjectile: + case eBaseTypeDestructObj: + case eBaseTypeNPC: + case eBaseTypeBoulder: + *bnd = *(xBound*)((int)tgt + 0x64); + break; + default: + retval = 0; + break; + case eBaseTypeCruiseBubble: + break; } return retval; } S32 NPCC_pos_ofBase(xBase* tgt, xVec3* pos) { - xVec3 *pxVar1; + xVec3* pxVar1; S32 retval = 1; - switch(tgt->baseType) - { - case eBaseTypeCamera: - xVec3Copy(pos, &globals.camera.mat.pos); - break; - case eBaseTypeCruiseBubble: - retval = 0; - break; - case eBaseTypePlayer: - case eBaseTypePickup: - case eBaseTypePlatform: - case eBaseTypeStatic: - case eBaseTypeDynamic: - case eBaseTypeBubble: - case eBaseTypePendulum: - case eBaseTypeHangable: - case eBaseTypeButton: - case eBaseTypeProjectile: - case eBaseTypeDestructObj: - case eBaseTypeNPC: - case eBaseTypeBoulder: - xVec3Copy(pos, xEntGetPos((xEnt *)tgt)); - break; - case eBaseTypeDoor: - case eBaseTypeVolume: - case eBaseTypeEGenerator: - retval = 0; - break; - default: - retval = 0; - break; + switch (tgt->baseType) + { + case eBaseTypeCamera: + xVec3Copy(pos, &globals.camera.mat.pos); + break; + case eBaseTypeCruiseBubble: + retval = 0; + break; + case eBaseTypePlayer: + case eBaseTypePickup: + case eBaseTypePlatform: + case eBaseTypeStatic: + case eBaseTypeDynamic: + case eBaseTypeBubble: + case eBaseTypePendulum: + case eBaseTypeHangable: + case eBaseTypeButton: + case eBaseTypeProjectile: + case eBaseTypeDestructObj: + case eBaseTypeNPC: + case eBaseTypeBoulder: + xVec3Copy(pos, xEntGetPos((xEnt*)tgt)); + break; + case eBaseTypeDoor: + case eBaseTypeVolume: + case eBaseTypeEGenerator: + retval = 0; + break; + default: + retval = 0; + break; } return retval; } @@ -483,19 +1069,19 @@ void NPCTarget::PosGet(xVec3* pos) { switch (typ_target) { - case NPC_TGT_NONE: - break; - case NPC_TGT_PLYR: - case NPC_TGT_ENT: - case NPC_TGT_BASE: - NPCC_pos_ofBase(bas_target, pos); - break; - case NPC_TGT_POS: - xVec3Copy(pos, &pos_target); - break; - case NPC_TGT_MVPT: - xVec3Copy(pos, zMovePointGetPos(nav_target)); - break; + case NPC_TGT_NONE: + break; + case NPC_TGT_PLYR: + case NPC_TGT_ENT: + case NPC_TGT_BASE: + NPCC_pos_ofBase(bas_target, pos); + break; + case NPC_TGT_POS: + xVec3Copy(pos, &pos_target); + break; + case NPC_TGT_MVPT: + xVec3Copy(pos, zMovePointGetPos(nav_target)); + break; } } @@ -525,6 +1111,70 @@ void NPCC_xBoundBack(xBound* bnd) void NPCC_DstSq(const xVec3*, const xVec3*, xVec3*); +S32 NPCC_HaveLOSToPos(xVec3* pos_src, xVec3* pos_tgt, F32 dst_max, xBase* tgt, xCollis* colCallers) +//NONMATCH("https://decomp.me/scratch/LyDtk") +{ + S32 result; + xRay3 ray = {}; + xScene* xscn = globals.sceneCur; + xCollis* colrec; + + if (colCallers) + { + colrec = colCallers; + } + else + { + static xCollis localCollis = { (((U32)(1 << 8)) | ((U32)(1 << 9)) | ((U32)(1 << 10)) | + ((U32)(1 << 11))) | + ((U32)(1 << 12)) }; + + memset(&localCollis, 0, sizeof(xCollis)); + localCollis.flags = + (((U32)(1 << 8)) | ((U32)(1 << 9)) | ((U32)(1 << 10)) | ((U32)(1 << 11))) | + ((U32)(1 << 12)) | ((U32)(1 << 12)); + + colrec = &localCollis; + } + + ray.min_t = 0.0f; + ray.max_t = dst_max; + + xVec3Sub(&ray.dir, pos_tgt, pos_src); + xVec3Normalize(&ray.dir, &ray.dir); + xVec3Copy(&ray.origin, pos_src); + + ray.flags = (1 << 10) | (1 << 11); + + xRayHitsScene(xscn, &ray, colrec); + + if (!(colrec->flags & ((U32)(1 << 0)))) + { + result = 1; + } + else if (colrec->dist > dst_max) + { + result = 1; + } + else if (tgt && colrec->oid != 0) + { + if (tgt->id == colrec->oid) + { + result = 1; + } + else + { + result = 0; + } + } + else + { + result = 0; + } + + return result; +} + void NPCC_DstSqPlyrToPos(const xVec3* pos) { NPCC_DstSq(pos, xEntGetPos(&globals.player.ent), NULL); @@ -535,7 +1185,7 @@ F32 NPCC_ds2_toCam(const xVec3* pos_from, xVec3* delta) xVec3 delt = {}; xVec3Sub(&delt, &globals.camera.mat.pos, pos_from); F32 retval = xVec3Length2(&delt); - if (delta != (xVec3 *)0) + if (delta != (xVec3*)0) { xVec3Copy(delta, &delt); } @@ -606,4 +1256,4 @@ void NPCC_MakeArbPlane(const xVec3* dir_norm, xVec3* at, xVec3* rt) { NPCC_MakePerp(at, dir_norm); xVec3Cross(rt, at, dir_norm); -} \ No newline at end of file +} diff --git a/src/SB/Game/zNPCSupport.h b/src/SB/Game/zNPCSupport.h index b69007b43..65b750a53 100644 --- a/src/SB/Game/zNPCSupport.h +++ b/src/SB/Game/zNPCSupport.h @@ -70,6 +70,8 @@ struct NPCTarget void PosGet(xVec3* pos); void TargetSet(xEnt* ent, int b); S32 IsDead(); + S32 FindNearest(S32 flg_consider, xBase* skipme, xVec3* from, F32 dst_max); + S32 InCylinder(xVec3* from, F32 rad, F32 hyt, F32 off); }; struct NPCBlinker @@ -91,8 +93,8 @@ struct NPCWidget S32 NPCIsTheLocker(const zNPCCommon* npc_lock); U32 IsLocked(); S32 IsVisible(); - U32 Off(zNPCCommon* npc, U32 theman); - U32 On(const zNPCCommon* npc, S32 theman); + S32 Off(const zNPCCommon* npc, S32 theman); + S32 On(const zNPCCommon* npc, S32 theman); void Reset(); void Init(en_NPC_UI_WIDGETS); S32 Lock(const zNPCCommon*); @@ -150,6 +152,7 @@ F32 NPCC_TmrCycle(F32* tmr, F32 dt, F32 interval); xVec3* NPCC_rightDir(xEnt* ent); xVec3* NPCC_faceDir(xEnt* ent); void NPCC_ang_toXZDir(F32 angle, xVec3* dir); +F32 NPCC_dir_toXZAng(const xVec3* dir); F32 NPCC_aimVary(xVec3* dir_aim, xVec3* pos_src, xVec3* pos_tgt, F32 dst_vary, S32 flg_vary, xVec3* pos_aimPoint); void NPCC_aimMiss(xVec3*, xVec3*, xVec3*, float, xVec3*); @@ -159,5 +162,7 @@ F32 NPCC_ds2_toCam(const xVec3* pos_from, xVec3* delta); void zNPC_SNDStop(_tageNPCSnd snd); void zNPC_SNDPlay3D(_tageNPCSnd snd, xEnt*); RwRaster* NPCC_FindRWRaster(char*); +void NPCC_xBoundAway(xBound* bnd); +void NPCC_xBoundBack(xBound* bnd); #endif diff --git a/src/SB/Game/zNPCTypeCommon.cpp b/src/SB/Game/zNPCTypeCommon.cpp index 3eb5e7a37..b898bfa59 100644 --- a/src/SB/Game/zNPCTypeCommon.cpp +++ b/src/SB/Game/zNPCTypeCommon.cpp @@ -16,6 +16,9 @@ #include "xString.h" #include "xDebug.h" +#include "xBound.h" + +// Finish porting code from bfbbpc repo #define Unknown 0 #define LassoGuide_Grab01 1 @@ -26,6 +29,7 @@ static char* g_strz_lassanim[3] = { "Unknown", "LassoGuide_Grab01", "LassoGuide_ extern S32 g_hash_lassanim[3]; extern volatile S32 g_skipDescent; extern NPCConfig* g_ncfghead; +static zNPCSettings* g_dflt_npcsettings; extern NPCSndTrax g_sndTrax_General[]; extern F32 lbl_803CE4C0; extern S32 g_flg_wonder; @@ -33,6 +37,84 @@ extern S32 g_isConversation; extern xBase* g_ownerConversation; extern F32 g_tmr_talkless; +static char* g_strz_params[NPC_PARM_NOMORE] = { + "Empty", + "MoveSpeed", + "TurnSpeed", + "FactorAccel", + "FactorDrift", + "FactorMass", + "FactorGravKnock", + "FactorElasticity", + "BoundMainIsBox", + "BoundMainCenter", + "BoundMainExtent", + "HitPoints", + "ScaleModel", + "DetectRadius", + "DetectHeight", + "DetectOffset", + "AttackRadius", + "AttackFOV", + "SoundRadius", + "DelayFidget", + "AttackPeriod", + "StunTime", + "AlertTime", + "VtxAttackBase", + "VtxAttack", + "VtxAttack1", + "VtxAttack2", + "VtxAttack3", + "VtxAttack4", + "VtxEyeball", + "VtxDmgSmokeA", + "VtxDmgSmokeB", + "VtxDmgSmokeC", + "VtxDmgFlameA", + "VtxDmgFlameB", + "VtxDmgFlameC", + "VtxPropel", + "VtxExhaust", + "VtxGen01", + "VtxGen02", + "VtxGen03", + "VtxGen04", + "VtxGen05", + "AttackSize01", + "AttackFrames01", + "AttackFrames01a", + "AttackFrames01b", + "AttackFrames02", + "AttackFrames02a", + "AttackFrames02b", + "AttackFrames03", + "AttackFrames03a", + "AttackFrames03b", + "EsteemSlotA", + "EsteemSlotB", + "EsteemSlotC", + "EsteemSlotD", + "EsteemSlotE", + "DistShadowCast", + "ShadowCacheRadius", + "ShadowRasterRadius", + "TestCount", + "EndTag_INIOnly", + "FirstMovepoint", + "EndTag_PropsOnly", + "Bogus_Share", + "EndTag_Shared", +}; + +static en_npcparm mdlVertToParm[NPC_MDLVERT_NOMORE] = { + NPC_PARM_VTX_ATTACKBASE, NPC_PARM_VTX_ATTACK, NPC_PARM_VTX_ATTACK1, NPC_PARM_VTX_ATTACK2, + NPC_PARM_VTX_ATTACK3, NPC_PARM_VTX_ATTACK4, NPC_PARM_VTX_EYEBALL, NPC_PARM_VTX_DMGSMOKEA, + NPC_PARM_VTX_DMGSMOKEB, NPC_PARM_VTX_DMGSMOKEC, NPC_PARM_VTX_DMGFLAMEA, NPC_PARM_VTX_DMGFLAMEB, + NPC_PARM_VTX_DMGFLAMEC, NPC_PARM_VTX_PROPEL, NPC_PARM_VTX_EXHAUST, NPC_PARM_VTX_GEN01, + NPC_PARM_VTX_GEN02, NPC_PARM_VTX_GEN03, NPC_PARM_VTX_GEN04, NPC_PARM_VTX_GEN05, +}; + xFactoryInst* ZNPC_Create_Common(S32 who, RyzMemGrow* grow, void*) { zNPCCommon* com = NULL; @@ -116,138 +198,2691 @@ void zNPCCommon_Timestep(xScene* scene, F32 dt) } } -void zNPCCommon::Destroy() +void zNPCCommon::Init(xEntAsset* entass) { - SelfDestroy(); -} + xSceneID2Name(globals.sceneCur, entass->id); + xNPCBasic::Init(entass); -void zNPCCommon::Process(xScene* xscn, F32 dt) -{ - if ((flg_misc & 4) != 0) + this->entass = entass; + this->npcass = (xEntNPCAsset*)(entass + 1); + + xLinkAsset* npclinx = (xLinkAsset*)(this->npcass + 1); + if (linkCount) { - ModelScaleSet(&cfg_npc->scl_model); + this->link = npclinx; } - flags1.flg_upward = flags1.flg_upward & ~0x2; - xNPCBasic::Process(xscn, dt); + else + { + this->link = NULL; + } + + this->parmdata = zEntGetModelParams(this->entass->modelInfoID, &this->pdatsize); + + this->cfg_npc = this->ConfigFind(this->entass->modelInfoID); + if (!this->cfg_npc) + { + this->cfg_npc = this->ConfigCreate(this->entass->modelInfoID); + this->ParseINI(); + } + + if (this->cfg_npc && xVec3Length2(&this->cfg_npc->scl_model) > 0.0f) + { + this->flg_misc |= 0x4; + } + + this->InitBounds(); } -void zNPCCommon::ParseProps() +void zNPCCommon::InitBounds() //NONMATCH("https://decomp.me/scratch/JPhdS") { - for (S32 i = 0x3f; i < 0x42; i++) + NPCConfig* cfg = this->cfg_npc; + xVec3 half = {}; + xSphere* sph = &this->bound.sph; + xBBox* box = &this->bound.box; + + if (cfg->useBoxBound) { - switch (i) + this->bound.type = XBOUND_TYPE_BOX; + } + else + { + this->bound.type = XBOUND_TYPE_SPHERE; + } + + S32 r28; + if (xVec3Length2(&cfg->off_bound) > 0.0f) + { + r28 = 1; + } + else + { + r28 = 0; + } + + if (xVec3Length2(&cfg->dim_bound) > 0.0f) + { + xSceneID2Name(globals.sceneCur, this->id); + this->DBG_Name(); + + if (this->bound.type == XBOUND_TYPE_SPHERE) { - case 0x3f: - MvptReset(NULL); + sph->r = cfg->dim_bound.x; + xVec3Copy(&sph->center, xEntGetPos(this)); + xVec3AddTo(&sph->center, &cfg->off_bound); + } + else + { + xVec3SMul(&half, &cfg->dim_bound, 0.5f); + xVec3Copy(&box->center, xEntGetPos(this)); + xVec3AddTo(&box->center, &cfg->off_bound); + xVec3Add(&box->box.upper, &box->center, &half); + xVec3Sub(&box->box.lower, &box->center, &half); + } + } + else + { + xSceneID2Name(globals.sceneCur, this->id); + this->DBG_Name(); + + switch (this->bound.type) + { + case XBOUND_TYPE_SPHERE: + iSphereForModel(sph, this->model); + cfg->dim_bound.x = sph->r; + cfg->dim_bound.y = 0.0f; + cfg->dim_bound.z = 0.0f; + if (!r28) + { + xVec3Copy(&cfg->off_bound, &sph->center); + cfg->off_bound.y = MAX(cfg->off_bound.y, sph->r); + } + sph->r = cfg->dim_bound.x; + xVec3Copy(&sph->center, xEntGetPos(this)); + xVec3AddTo(&sph->center, &cfg->off_bound); break; - default: + case XBOUND_TYPE_BOX: + case XBOUND_TYPE_OBB: + iBoxForModel(&box->box, this->model); + xVec3Sub(&cfg->dim_bound, &box->box.upper, &box->box.lower); + if (!r28) + { + xVec3SMul(&cfg->off_bound, &cfg->dim_bound, 0.5f); + } + xVec3SMul(&half, &cfg->dim_bound, 0.5f); + xVec3Copy(&box->center, xEntGetPos(this)); + xVec3AddTo(&box->center, &cfg->off_bound); + xVec3Add(&box->box.upper, &box->center, &half); + xVec3Sub(&box->box.lower, &box->center, &half); break; } } } -bool zNPCCommon::IsMountableType(en_ZBASETYPE type) +void zNPCCommon::Setup() { - switch (type) + xSceneID2Name(globals.sceneCur, this->id); + + xNPCBasic::Setup(); + + this->DBG_InstName(); + this->DBG_RptDataSize(); + + this->npcsetass = zNPCSettings_Find(this->npcass->npcProps); + + this->ParseLinks(); + + if (this->LassoInit()) { - case eBaseTypePlatform: - return true; + this->LassoSetup(); + } + + this->SelfSetup(); + this->DBG_AddTweakers(); + + switch (this->SelfType()) + { + case NPC_TYPE_HAMMER: + case NPC_TYPE_HAMSPIN: + this->explosion = (zShrapnelAsset*)xSTFindAsset(xStrHash("hammer_shrapnel"), NULL); + break; + case NPC_TYPE_TARTAR: + this->explosion = (zShrapnelAsset*)xSTFindAsset(xStrHash("tartar_shrapnel"), NULL); + break; + case NPC_TYPE_FODDER: + this->explosion = (zShrapnelAsset*)xSTFindAsset(xStrHash("fodder_shrapnel"), NULL); + break; + case NPC_TYPE_FODBZZT: + this->explosion = (zShrapnelAsset*)xSTFindAsset(xStrHash("robot_0a_bzzt_shrapnel"), NULL); + break; + case NPC_TYPE_CHOMPER: + this->explosion = + (zShrapnelAsset*)xSTFindAsset(xStrHash("robot_0a_chomper_shrapnel"), NULL); + break; + case NPC_TYPE_GLOVE: + this->explosion = (zShrapnelAsset*)xSTFindAsset(xStrHash("g-love_shrapnel"), NULL); + break; + case NPC_TYPE_MONSOON: + this->explosion = + (zShrapnelAsset*)xSTFindAsset(xStrHash("robot_4a_monsoon_shrapnel"), NULL); + break; + case NPC_TYPE_SLEEPY: + this->explosion = + (zShrapnelAsset*)xSTFindAsset(xStrHash("robot_sleepy-time_shrapnel"), NULL); + break; + case NPC_TYPE_ARFARF: + this->explosion = (zShrapnelAsset*)xSTFindAsset(xStrHash("robot_arf_shrapnel"), NULL); + break; + case NPC_TYPE_CHUCK: + this->explosion = (zShrapnelAsset*)xSTFindAsset(xStrHash("robot_chuck_shrapnel"), NULL); + break; + case NPC_TYPE_SLICK: + this->explosion = (zShrapnelAsset*)xSTFindAsset(xStrHash("robot_9a_shrapnel"), NULL); + break; + case NPC_TYPE_DUPLOTRON: + this->explosion = + (zShrapnelAsset*)xSTFindAsset(xStrHash("duplicatotron1000_shrapnel"), NULL); + break; + case NPC_TYPE_TIKI_WOOD: + this->explosion = (zShrapnelAsset*)xSTFindAsset(xStrHash("tiki_wooden_shrapnel"), NULL); + break; + case NPC_TYPE_TIKI_QUIET: + this->explosion = (zShrapnelAsset*)xSTFindAsset(xStrHash("tiki_shhhh_shrapnel"), NULL); + break; + case NPC_TYPE_TIKI_THUNDER: + this->explosion = (zShrapnelAsset*)xSTFindAsset(xStrHash("tiki_thunder_shrapnel"), NULL); + break; + case NPC_TYPE_TIKI_LOVEY: + this->explosion = + (zShrapnelAsset*)xSTFindAsset(xStrHash("tiki_lovey_dovey_shrapnel"), NULL); + break; + case NPC_TYPE_TIKI_STONE: + this->explosion = (zShrapnelAsset*)xSTFindAsset(xStrHash("tiki_stone_shrapnel"), NULL); break; default: - return false; + this->explosion = NULL; break; } -} -void zNPCCommon::SelfDestroy() -{ - xBehaveMgr* bmgr = xBehaveMgr_GetSelf(); - if (psy_instinct != NULL) + S32 wason = 0; + xPsyche* psy = this->psy_instinct; + + if (psy) { - bmgr->UnSubscribe(psy_instinct); + if (psy->ImmTranIsOn()) + { + wason = 1; + } + psy->ImmTranOff(); } - psy_instinct = NULL; -} -S32 zNPCCommon::GetVertPos(en_mdlvert vid, xVec3* pos) -{ - NPCConfig* cfg = cfg_npc; - if (!(cfg->flg_vert & 1 << vid)) + this->Reset(); + + if (psy && wason) { - return 0; + psy->ImmTranOn(); } - iModelTagEval(model->Data, &cfg->tag_vert[vid], model->Mat, pos); - return 1; } -void zNPCPlyrSnd_Reset() +void zNPCCommon::Reset() //NONMATCH("https://decomp.me/scratch/cl84A") { - g_tmr_talkless = 10.0f; -} + xSceneID2Name(globals.sceneCur, this->id); -void zNPCPlyrSnd_Update(F32 dt) -{ - g_tmr_talkless = MAX(-1.0f, g_tmr_talkless - dt); -} + xNPCBasic::Reset(); -void zNPCCommon::ConfigSceneDone() -{ - g_ncfghead = 0; + this->entShadow->dst_cast = this->cfg_npc->dst_castShadow; + this->entShadow->radius[0] = this->cfg_npc->rad_shadowCache; + this->entShadow->radius[1] = this->cfg_npc->rad_shadowRaster; + + this->ParseProps(); + + this->npcset = *this->npcsetass; + + if (this->entass->flags & XENT_COLLTYPE_DYN) + { + xEntShow(this); + } + else + { + xEntHide(this); + } + + if (this->flg_move & 0x2) + { + this->pflags |= XENT_COLLTYPE_DYN; + } + else if (this->flg_move & 0x4) + { + this->pflags &= (U8)~XENT_COLLTYPE_DYN; + } + else + { + this->pflags &= (U8)~XENT_COLLTYPE_DYN; + } + + if (this->model->Anim) + { + xAnimPlaySetState(this->model->Anim->Single, &this->model->Anim->Table->StateList[0], 0.0f); + } + + this->drv_data = this->PRIV_GetDriverData(); + if (this->drv_data) + { + xEntDriveInit(this->drv_data, this); + this->drv_data->flags |= 0x1; + } + + if (this->lassdata) + { + this->lassdata->stage = LASS_STAT_PENDING; + } } -void zNPCCommon_WonderReset() +void zNPCCommon::Destroy() { - g_isConversation = 0; - g_flg_wonder = 0; + SelfDestroy(); } -U32 zNPCCommon::CanDoSplines() +void zNPCCommon::Damage(en_NPC_DAMAGE_TYPE damtype, xBase* who, const xVec3* vec_hit) { - bool retval = false; - if ((npcset.useNavSplines) && ((flg_move) & 8)) + static NPCMsg msg; + NPCDamageInfo* dmg = &msg.dmgdata; + + if (!(this->flg_vuln & 0x1)) + return; + if (who && who->baseType == eBaseTypePlayer && !(this->flg_vuln & 0xFFFF0000)) + return; + + switch (damtype) { - retval = true; + case DMGTYP_ABOVE: + if (!(this->flg_vuln & 0x40000)) + return; + break; + case DMGTYP_BELOW: + if (!(this->flg_vuln & 0x20000)) + return; + break; + case DMGTYP_SIDE: + if (gCurrentPlayer == eCurrentPlayerSpongeBob) + { + if (!(this->flg_vuln & 0x10000)) + return; + } + else if (gCurrentPlayer == eCurrentPlayerPatrick) + { + if (!(this->flg_vuln & 0x80000000)) + return; + } + else if (gCurrentPlayer == eCurrentPlayerSandy) + { + if (!(this->flg_vuln & 0x2000000)) + return; + } + else + { + if (!(this->flg_vuln & 0x10000)) + return; + } + break; + case DMGTYP_INSTAKILL: + this->tmr_invuln = -1.0f; + break; + case DMGTYP_HITBYTOSS: + if (!(this->flg_vuln & 0x4)) + return; + break; + case DMGTYP_NPCATTACK: + if (!(this->flg_vuln & 0x8)) + return; + break; + case DMGTYP_ROPE: + if (!(this->flg_vuln & 0x1000000)) + return; + break; + case DMGTYP_CRUISEBUBBLE: + if (!(this->flg_vuln & 0x80000)) + return; + break; + case DMGTYP_PROJECTILE: + if (!(this->flg_vuln & 0x8)) + return; + break; + case DMGTYP_BUBBOWL: + if (!(this->flg_vuln & 0x100000)) + return; + break; + case DMGTYP_BOULDER: + if (!(this->flg_vuln & 0x200000)) + return; + break; + case DMGTYP_THUNDER_TIKI_EXPLOSION: + if (!(this->flg_vuln & 0x2)) + return; + break; + case DMGTYP_DAMAGE_SURFACE: + case DMGTYP_SURFACE: + if (!(this->flg_vuln & 0x10)) + return; + break; + case DMGTYP_BUNGEED: + if (!(this->flg_vuln & 0x400000)) + return; + break; } - return retval; -} -zMovePoint* zNPCCommon::FirstAssigned() -{ - zMovePoint* nav_first = NULL; - zNPCCommon::GetParm(NPC_PARM_FIRSTMVPT, &nav_first); - return nav_first; + if (this->tmr_invuln < 0.0f) + { + this->tmr_invuln = 0.5f; + + memset(&msg, 0, sizeof(msg)); + + msg.from = this->id; + msg.sendto = this->id; + msg.msgid = NPC_MID_DAMAGE; + msg.infotype = NPC_MDAT_DAMAGE; + + dmg->dmg_type = damtype; + dmg->dmg_from = who; + + if (vec_hit) + { + xVec3Copy(&dmg->vec_dmghit, vec_hit); + } + else + { + xVec3Copy(&dmg->vec_dmghit, &g_O3); + } + + zNPCMsg_SendMsg(&msg, this); + } } -U32 zNPCCommon::AnimCurStateID() +S32 zNPCCommon::Respawn(const xVec3* pos, zMovePoint* mvptFirst, zMovePoint* mvptSpawnRef) { - xAnimState* state = AnimCurState(); - if (state != NULL) + static NPCMsg msg; + + memset(&msg, 0, sizeof(msg)); + + msg.msgid = NPC_MID_RESPAWN; + msg.from = this->id; + msg.sendto = this->id; + msg.infotype = NPC_MDAT_SPAWN; + + if (pos) { - return state->ID; + xVec3Copy(&msg.spawning.pos_spawn, pos); } else { - return 0; + xVec3Copy(&msg.spawning.pos_spawn, &this->entass->pos); } -} -F32 zNPCCommon::AnimDuration(xAnimState* ast) -{ - if (ast == 0) + if (mvptFirst) { - ast = AnimCurState(); + msg.spawning.nav_firstMovepoint = mvptFirst; + } + else + { + msg.spawning.nav_firstMovepoint = NULL; } - return (ast == 0) ? 0.0f : ast->Data->Duration; -} -F32 zNPCCommon::AnimTimeRemain(xAnimState* ast) -{ - return (AnimDuration(ast) - AnimTimeCurrent()); + msg.spawning.nav_spawnReference = mvptSpawnRef; + msg.spawning.spawnSuccess = 0; + + zNPCMsg_SendMsg(&msg, this); + + return msg.spawning.spawnSuccess; } -F32 zNPCCommon::AnimTimeCurrent() +S32 zNPCCommon::NPCMessage(NPCMsg* mail) { - return model->Anim->Single->Time; + S32 handled = 1; + + switch (mail->msgid) + { + case NPC_MID_SYSEVENT: + { + xPsyche* psy = this->psy_instinct; + + switch (mail->sysevent.toEvent) + { + case eEventNPCPatrolOn: + this->npcset.allowPatrol = 1; + break; + case eEventNPCPatrolOff: + this->npcset.allowPatrol = 0; + break; + case eEventNPCWanderOn: + this->npcset.allowDetect = 1; + break; + case eEventNPCWanderOff: + this->npcset.allowDetect = 0; + break; + case eEventNPCDetectOn: + this->npcset.allowDetect = 1; + break; + case eEventNPCDetectOff: + this->npcset.allowDetect = 0; + break; + case eEventNPCChaseOn: + this->npcset.allowChase = 1; + break; + case eEventNPCChaseOff: + this->npcset.allowChase = 0; + break; + case eEventNPCSplineOKOn: + this->npcset.useNavSplines = 1; + break; + case eEventNPCSplineOKOff: + this->npcset.useNavSplines = 0; + break; + case eEventNPCSetActiveOff: + if (psy && psy->HasGoal(NPC_GOAL_LIMBO)) + { + psy->GoalSet(NPC_GOAL_LIMBO, 1); + } + break; + case eEventNPCSetActiveOn: + if (psy) + { + psy->GIDOfPending(); + + S32 r4 = psy->GIDOfSafety(); + if (r4) + { + psy->GoalSet(r4, 1); + } + } + break; + default: + handled = 0; + break; + } + break; + } + case NPC_MID_RESPAWN: + { + xVec3Copy(xEntGetPos(this), &mail->spawning.pos_spawn); + + zMovePoint* mvpt = mail->spawning.nav_spawnReference; + if (!mvpt) + mvpt = mail->spawning.nav_firstMovepoint; + + this->nav_past = mvpt; + this->nav_curr = mvpt; + this->nav_dest = mvpt; + this->nav_lead = mvpt; + + mail->spawning.spawnSuccess = 1; + break; + } + case NPC_MID_DAMAGE: + break; + case NPC_MID_DEV_ANIMCYCLE: + if (this->psy_instinct && this->psy_instinct->HasGoal(NPC_GOAL_DEVANIMSPIN)) + { + this->psy_instinct->GoalSet(NPC_GOAL_DEVANIMSPIN, 0); + } + break; + case NPC_MID_DEV_ANIMSPIN: + if (this->psy_instinct && this->psy_instinct->HasGoal(NPC_GOAL_DEVANIMCYCLE)) + { + this->psy_instinct->GoalSet(NPC_GOAL_DEVANIMCYCLE, 0); + } + break; + case NPC_MID_DEV_HEROMODE: + if (this->psy_instinct && this->psy_instinct->HasGoal(NPC_GOAL_DEVANIMHERO)) + { + this->psy_instinct->GoalSet(NPC_GOAL_DEVANIMHERO, 0); + } + break; + case NPC_MID_DEV_DONE: + break; + default: + handled = 1; + break; + } + + return handled; +} + +void zNPCCommon::Move(xScene* xscn, F32 dt, xEntFrame* frm) +{ + bool retval = false; + if ((npcset.useNavSplines) && ((flg_move)&8)) + if (this->drv_data && (this->drv_data->driver || this->drv_data->odriver)) + { + retval = true; + S32 backit = 0; + xVec3 var_28; + + if (this->frame->mode & 0x2) + { + backit = 1; + var_28 = this->frame->dpos; + } + + xEntDriveUpdate(this->drv_data, xscn, dt, NULL); + + if (backit) + { + this->frame->mode |= 0x2; + this->frame->dpos = var_28; + } + } + + xNPCBasic::Move(xscn, dt, frm); +} + +void zNPCCommon::Process(xScene* xscn, F32 dt) +{ + if ((flg_misc & 4) != 0) + { + ModelScaleSet(&cfg_npc->scl_model); + } + flags1.flg_upward = flags1.flg_upward & ~0x2; + xNPCBasic::Process(xscn, dt); +} + +void zNPCCommon::BUpdate(xVec3* pos) //NONMATCH("https://decomp.me/scratch/zpv2r") +{ + NPCConfig* cfg = this->cfg_npc; + + if (cfg->useBoxBound) + { + this->bound.type = XBOUND_TYPE_BOX; + + xBBox* box = &this->bound.box; + xVec3 half = cfg->dim_bound * 0.5f; + + box->center = *pos + cfg->off_bound; + box->box.upper = box->center + half; + box->box.lower = box->center - half; + } + else + { + this->bound.type = XBOUND_TYPE_SPHERE; + + xSphere* sph = &this->bound.sph; + + sph->center = *pos + cfg->off_bound; + sph->r = cfg->dim_bound.x; + } + + if (this->bound.type != XBOUND_TYPE_NA) + { + xQuickCullForBound(&this->bound.qcd, &this->bound); + } + + zGridUpdateEnt(this); +} + +F32 zNPCCommon::BoundAsRadius(S32 useCfg) const //NONMATCH("https://decomp.me/scratch/rCFqE") +{ + F32 rad = 1.0f; + + if (useCfg) + { + NPCConfig* cfg = this->cfg_npc; + + if (cfg->useBoxBound) + { + xVec3 dim = cfg->dim_bound; + rad = (dim.x + dim.y + dim.z) * (1 / 6.f); + } + else + { + rad = cfg->dim_bound.x; + } + } + else + { + if (this->bound.type == XBOUND_TYPE_BOX) + { + const xBBox* box = &this->bound.box; + const xVec3* le = &box->box.lower; + const xVec3* ue = &box->box.upper; + rad = ((ue->x + ue->y + ue->z) - (le->x + le->y - le->z)) * (1 / 6.f); + } + else if (this->bound.type == XBOUND_TYPE_SPHERE) + { + rad = this->bound.sph.r; + } + } + + return rad; +} + +void zNPCCommon::NewTime(xScene* xscn, F32 dt) +{ + if (this->flg_misc & 0x2) + { + this->SndQueUpdate(dt); + } + + this->tmr_invuln = MAX(-1.0f, this->tmr_invuln - dt); + + xNPCBasic::NewTime(xscn, dt); +} + +S32 zNPCCommon::SysEvent(xBase* from, xBase* to, U32 toEvent, const F32* toParam, + xBase* toParamWidget, S32* handled) +{ + static NPCMsg npcmsg; + + S32 doOtherEvents = 1; + zNPCCommon* npc = (zNPCCommon*)to; + xVec3 pos = {}; + xVec3 dir = {}; + + *handled = 1; + + switch (toEvent) + { + case eEventSceneEnd: + { + xPsyche* psy = this->psy_instinct; + if (psy) + { + psy->GoalNone(1); + } + break; + } + case eEventNPCSpecial_PlatformSnap: + case eEventNPCSpecial_PlatformFall: + { + memset(&npcmsg, 0, sizeof(npcmsg)); + + npcmsg.msgid = NPC_MID_SYSEVENT; + npcmsg.infotype = NPC_MDAT_SYSEVENT; + npcmsg.from = this->id; + npcmsg.sendto = this->id; + + NPCSysEvent* se = &npcmsg.sysevent; + se->doLinkEvents = 1; + se->handled = 0; + se->to = to; + se->from = from; + se->toEvent = toEvent; + se->toParamWidget = toParamWidget; + + if (!toParam) + { + se->toParam[0] = 0.0f; + se->toParam[1] = 0.0f; + se->toParam[2] = 0.0f; + se->toParam[3] = 0.0f; + } + else + { + se->toParam[0] = toParam[0]; + se->toParam[1] = toParam[1]; + se->toParam[2] = toParam[2]; + se->toParam[3] = toParam[3]; + } + + zNPCMsg_SendMsg(&npcmsg, -1.0f, NULL); + + *handled = npcmsg.sysevent.handled; + doOtherEvents = se->doLinkEvents; + break; + } + case eEventHit: + this->ConvertHitEvent(from, to, toEvent, toParam, toParamWidget, handled); + break; + case eEventReset: + this->Reset(); + break; + case eEventVisible: + xEntShow(npc); + break; + case eEventInvisible: + xEntHide(npc); + break; + case eEventSetUpdateDistance: + if (globals.updateMgr) + { + if (toParam[0] <= 0.0f) + { + xUpdateCull_SetCB(globals.updateMgr, npc, xUpdateCull_AlwaysTrueCB, NULL); + } + else + { + FloatAndVoid dist; + dist.f = SQR(toParam[0]); + xUpdateCull_SetCB(globals.updateMgr, npc, xUpdateCull_DistanceSquaredCB, dist.v); + } + } + break; + case eEventLaunchShrapnel: + { + zShrapnelAsset* shrap = (zShrapnelAsset*)toParamWidget; + if (shrap && shrap->initCB) + { + xVec3 currVel; + xVec3Sub(&currVel, &npc->frame->mat.pos, &npc->frame->oldmat.pos); + xVec3SMulBy(&currVel, 1.0f / globals.update_dt); + + shrap->initCB(shrap, this->model, &currVel, NULL); + } + break; + } + case eEventNPCKillQuietly: + this->Damage(DMGTYP_KILLEVENT, from, NULL); + break; + case eEventKill: + this->Damage(DMGTYP_INSTAKILL, from, NULL); + break; + case eEventNPCRespawn: + this->Respawn(NULL, NULL, NULL); + break; + case eEventNPCPatrolOn: + case eEventNPCPatrolOff: + case eEventNPCWanderOn: + case eEventNPCWanderOff: + case eEventNPCDetectOn: + case eEventNPCDetectOff: + case eEventNPCChaseOn: + case eEventNPCChaseOff: + case eEventNPCFightOn: + case eEventNPCFightOff: + { + memset(&npcmsg, 0, sizeof(npcmsg)); + + npcmsg.msgid = NPC_MID_SYSEVENT; + npcmsg.infotype = NPC_MDAT_SYSEVENT; + npcmsg.from = this->id; + npcmsg.sendto = this->id; + + NPCSysEvent* se = &npcmsg.sysevent; + se->doLinkEvents = 1; + se->handled = 0; + se->to = to; + se->from = from; + se->toEvent = toEvent; + se->toParamWidget = toParamWidget; + + if (!toParam) + { + se->toParam[0] = 0.0f; + se->toParam[1] = 0.0f; + se->toParam[2] = 0.0f; + se->toParam[3] = 0.0f; + } + else + { + se->toParam[0] = toParam[0]; + se->toParam[1] = toParam[1]; + se->toParam[2] = toParam[2]; + se->toParam[3] = toParam[3]; + } + + zNPCMsg_SendMsg(&npcmsg, -1.0f, NULL); + + *handled = npcmsg.sysevent.handled; + doOtherEvents = se->doLinkEvents; + break; + } + case eEventNPCForceConverseStart: + if (NPCC_ForceTalkOk()) + { + memset(&npcmsg, 0, sizeof(npcmsg)); + + npcmsg.msgid = NPC_MID_SYSEVENT; + npcmsg.infotype = NPC_MDAT_SYSEVENT; + npcmsg.from = this->id; + npcmsg.sendto = this->id; + + NPCSysEvent* se = &npcmsg.sysevent; + se->doLinkEvents = 1; + se->handled = 0; + se->to = to; + se->from = from; + se->toEvent = toEvent; + se->toParamWidget = toParamWidget; + + if (!toParam) + { + se->toParam[0] = 0.0f; + se->toParam[1] = 0.0f; + se->toParam[2] = 0.0f; + se->toParam[3] = 0.0f; + } + else + { + se->toParam[0] = toParam[0]; + se->toParam[1] = toParam[1]; + se->toParam[2] = toParam[2]; + se->toParam[3] = toParam[3]; + } + + zNPCMsg_SendMsg(&npcmsg, -1.0f, NULL); + + *handled = npcmsg.sysevent.handled; + doOtherEvents = se->doLinkEvents; + } + + break; + case eEventNPCCheerForMe: + zNPCMsg_SendMsg(NPC_MID_CELEBRATE, this); + break; + case eEventNPCGoToSleep: + case eEventNPCWakeUp: + { + memset(&npcmsg, 0, sizeof(npcmsg)); + + npcmsg.msgid = NPC_MID_SYSEVENT; + npcmsg.infotype = NPC_MDAT_SYSEVENT; + npcmsg.from = this->id; + npcmsg.sendto = this->id; + + NPCSysEvent* se = &npcmsg.sysevent; + se->doLinkEvents = 1; + se->handled = 0; + se->to = to; + se->from = from; + se->toEvent = toEvent; + se->toParamWidget = toParamWidget; + + if (!toParam) + { + se->toParam[0] = 0.0f; + se->toParam[1] = 0.0f; + se->toParam[2] = 0.0f; + se->toParam[3] = 0.0f; + } + else + { + se->toParam[0] = toParam[0]; + se->toParam[1] = toParam[1]; + se->toParam[2] = toParam[2]; + se->toParam[3] = toParam[3]; + } + + zNPCMsg_SendMsg(&npcmsg, -1.0f, NULL); + + *handled = npcmsg.sysevent.handled; + doOtherEvents = se->doLinkEvents; + break; + } + case eEventNPCSetActiveOn: + case eEventNPCSetActiveOff: + this->SelfType(); + + if (this->psy_instinct) + { + memset(&npcmsg, 0, sizeof(npcmsg)); + + npcmsg.msgid = NPC_MID_SYSEVENT; + npcmsg.infotype = NPC_MDAT_SYSEVENT; + npcmsg.from = this->id; + npcmsg.sendto = this->id; + + NPCSysEvent* se = &npcmsg.sysevent; + se->doLinkEvents = 1; + se->handled = 0; + se->to = to; + se->from = from; + se->toEvent = toEvent; + se->toParamWidget = toParamWidget; + + if (!toParam) + { + se->toParam[0] = 0.0f; + se->toParam[1] = 0.0f; + se->toParam[2] = 0.0f; + se->toParam[3] = 0.0f; + } + else + { + se->toParam[0] = toParam[0]; + se->toParam[1] = toParam[1]; + se->toParam[2] = toParam[2]; + se->toParam[3] = toParam[3]; + } + + zNPCMsg_SendMsg(&npcmsg, -1.0f, NULL); + + *handled = npcmsg.sysevent.handled; + doOtherEvents = se->doLinkEvents; + } + + break; + case eEventDuploWaveBegin: + case eEventDuploWaveComplete: + case eEventDuploNPCBorn: + case eEventDuploNPCKilled: + case eEventDuploExpiredMaxNPC: + case eEventDuploPause: + case eEventDuploResume: + case eEventDuploKillKids: + { + memset(&npcmsg, 0, sizeof(npcmsg)); + + npcmsg.msgid = NPC_MID_SYSEVENT; + npcmsg.infotype = NPC_MDAT_SYSEVENT; + npcmsg.from = this->id; + npcmsg.sendto = this->id; + + NPCSysEvent* se = &npcmsg.sysevent; + se->doLinkEvents = 1; + se->handled = 0; + se->to = to; + se->from = from; + se->toEvent = toEvent; + se->toParamWidget = toParamWidget; + + if (!toParam) + { + se->toParam[0] = 0.0f; + se->toParam[1] = 0.0f; + se->toParam[2] = 0.0f; + se->toParam[3] = 0.0f; + } + else + { + se->toParam[0] = toParam[0]; + se->toParam[1] = toParam[1]; + se->toParam[2] = toParam[2]; + se->toParam[3] = toParam[3]; + } + + zNPCMsg_SendMsg(&npcmsg, -1.0f, NULL); + + *handled = npcmsg.sysevent.handled; + doOtherEvents = se->doLinkEvents; + break; + } + case eEventNPCScript_ScriptBegin: + zNPCMsg_SendMsg(NPC_MID_SCRIPTBEGIN, this); + break; + case eEventNPCScript_ScriptEnd: + zNPCMsg_SendMsg(NPC_MID_SCRIPTEND, this); + break; + case eEventNPCScript_SetPos: + if (toParamWidget) + { + NPCC_pos_ofBase(toParamWidget, &pos); + this->MatPosSet(&pos); + } + break; + case eEventNPCScript_SetDir: + if (toParamWidget) + { + NPCC_pos_ofBase(toParamWidget, &dir); + xVec3SubFrom(&dir, xEntGetPos(this)); + dir.y = 0.0f; + + if (xVec3Length2(&dir) > 0.001f) + { + xVec3Normalize(&dir, &dir); + xVec3Copy((xVec3*)&this->model->Mat->at, &dir); + xVec3Copy((xVec3*)&this->model->Mat->up, &g_Y3); + xVec3Cross((xVec3*)&this->model->Mat->right, &dir, &g_Y3); + } + } + break; + case eEventNPCScript_LookNormal: + case eEventNPCScript_LookAlert: + case eEventNPCScript_FaceWidget: + case eEventNPCScript_GotoWidget: + case eEventNPCScript_AttackWidget: + case eEventNPCScript_FollowWidget: + case eEventNPCScript_PlayAnim: + case eEventNPCScript_LeadPlayer: + zEventName(toEvent); + break; + case eEventUnknown: + case eEventMount: + case eEventDismount: + case eEventDeath: + case eEventSceneBegin: + case eEventRoomBegin: + case eEventRoomEnd: + case eEventNPCScript_ScriptReady: + case eEventNPCScript_Halt: + case eEventNPCScript_FaceWidgetDone: + case eEventNPCScript_GotoWidgetDone: + case eEventNPCScript_AttackWidgetDone: + case eEventNPCScript_PlayAnimDone: + break; + default: + *handled = 0; + doOtherEvents = xNPCBasic::SysEvent(from, to, toEvent, toParam, toParamWidget, handled); + break; + } + + return doOtherEvents; +} + +void zNPCCommon::ConvertHitEvent(xBase* from, xBase* to, U32 toEvent, const F32* toParam, + xBase* toParamWidget, S32* handled) +{ + xVec3 pos_cruiser = {}; + xVec3* vec_hit = NULL; + F32 mag; + en_NPC_DAMAGE_TYPE what = DMGTYP_UNDECIDED; + + if (from) + { + switch (from->baseType) + { + case eBaseTypePlayer: + { + U32 mvinf = zEntPlayer_MoveInfo(); + if (mvinf & 0x8) + { + what = DMGTYP_BELOW; + } + else if (mvinf & 0x10) + { + what = DMGTYP_ABOVE; + } + else if (mvinf & 0x20) + { + what = DMGTYP_SIDE; + } + else + { + what = DMGTYP_SIDE; + } + + xVec3Sub(&pos_cruiser, xEntGetPos(&globals.player.ent), xEntGetPos(this)); + vec_hit = &pos_cruiser; + break; + } + case eBaseTypeCruiseBubble: + what = DMGTYP_CRUISEBUBBLE; + + if (toParam) + { + pos_cruiser.x = toParam[0]; + pos_cruiser.y = toParam[1]; + pos_cruiser.z = toParam[2]; + + mag = xVec3Length(&pos_cruiser); + if (mag > 0.001f) + { + xVec3SubFrom(&pos_cruiser, xEntGetPos(this)); + xVec3SMulBy(&pos_cruiser, 2.0f / mag); + + vec_hit = &pos_cruiser; + } + } + + break; + case eBaseTypeProjectile: + what = DMGTYP_PROJECTILE; + break; + case eBaseTypeBoulder: + if (globals.player.bubblebowl && globals.player.bubblebowl == (xEntBoulder*)from) + { + what = DMGTYP_BUBBOWL; + } + else + { + what = DMGTYP_BOULDER; + } + break; + } + } + + this->Damage(what, from, vec_hit); +} + +void zNPCCommon::VelStop() //NONMATCH("https://decomp.me/scratch/YizcX") +{ + this->spd_throttle = 0.0f; + this->frame->dvel.x = 0.0f; + this->frame->dvel.y = 0.0f; + this->frame->dvel.z = 0.0f; + this->frame->vel.x = 0.0f; + this->frame->vel.y = 0.0f; + this->frame->vel.z = 0.0f; + this->frame->mode |= 0xC; + + if (!this->drv_data) + { + this->frame->dpos.x = 0.0f; + this->frame->dpos.y = 0.0f; + this->frame->dpos.z = 0.0f; + this->frame->mode |= 0x2; + } + else if (!this->drv_data->driver) + { + this->frame->dpos.x = 0.0f; + this->frame->dpos.y = 0.0f; + this->frame->dpos.z = 0.0f; + this->frame->mode |= 0x2; + } +} + +F32 zNPCCommon::ThrottleAdjust(F32 dt, F32 spd_want, F32 accel) +{ + NPCConfig* cfg = this->cfg_npc; + F32 acc; + S32 speedup = (spd_want > this->spd_throttle); + + acc = (accel < 0.0f) ? (dt * cfg->fac_accelMax) : (dt * accel); + + if (xeq(spd_want, this->spd_throttle, acc)) + { + this->spd_throttle = spd_want; + return this->spd_throttle; + } + + if (speedup) + { + this->spd_throttle += acc; + this->spd_throttle = CLAMP(this->spd_throttle, 0.0f, spd_want); + } + else + { + this->spd_throttle -= acc; + this->spd_throttle = MAX(spd_want, this->spd_throttle); + } + + return this->spd_throttle; +} + +F32 zNPCCommon::ThrottleAccel(F32 dt, S32 speedup, F32 pct_max) +{ + NPCConfig* cfg = this->cfg_npc; + F32 acc = dt * cfg->fac_accelMax; + F32 spd_top = pct_max * cfg->spd_moveMax; + + if (speedup) + { + this->spd_throttle += acc; + } + else + { + this->spd_throttle -= acc; + } + + this->spd_throttle = CLAMP(this->spd_throttle, 0.0f, spd_top); + + return this->spd_throttle; +} + +F32 zNPCCommon::ThrottleApply(F32 dt, const xVec3* dir, S32 force3D) +{ + xVec3 var_30; + if (xVec3Length2(dir) < 0.00001f) + { + var_30 = *NPCC_faceDir(this) * this->spd_throttle; + } + else + { + var_30 = *dir * this->spd_throttle; + } + + var_30 *= dt; + + if ((this->flg_move & 0x2) && !force3D) + { + this->frame->dpos.x = var_30.x; + this->frame->dpos.z = var_30.z; + } + else + { + this->frame->dpos = var_30; + } + + this->frame->mode |= 0x2; + + return this->spd_throttle; +} + +F32 zNPCCommon::TurnToFace(F32 dt, const xVec3* dir_want, F32 useTurnRate) +//NONMATCH("https://decomp.me/scratch/KRonE") +{ + F32 f29 = (useTurnRate < 0.0f) ? (dt * this->cfg_npc->spd_turnMax) : (dt * useTurnRate); + F32 f30 = NPCC_dir_toXZAng(dir_want); + F32 f31 = NPCC_dir_toXZAng(NPCC_faceDir(this)); + + F32 f28 = this->frame->rot.angle; + if (this->frame->mode & 0x20) + { + f28 += this->frame->drot.angle; + } + + F32 f1_ = xDangleClamp(f30 - f28); + F32 f2_ = CLAMP(f1_, -f29, f29); + F32 f2 = CLAMP(f28 + f2_, f31 - f29, f31 + f29); + F32 f1 = f2 - f28; + + this->frame->drot.angle = f1; + this->frame->mode |= 0x20; + + return f1; + + /* + F32 ang_caller; + F32 ang_wouldbe; + F32 rot_lim; + F32 ang_true; + F32 ang_past; + F32 ang_diff; + */ +} + +void zNPCCommon::ParseLinks() +{ + for (S32 i = 0; i < this->linkCount; i++) + { + switch (this->link[i].srcEvent) + { + case eEventNPCScript_ScriptBegin: + case eEventNPCScript_ScriptEnd: + case eEventNPCScript_ScriptReady: + case eEventNPCScript_Halt: + case eEventNPCScript_SetPos: + case eEventNPCScript_SetDir: + case eEventNPCScript_LookNormal: + case eEventNPCScript_LookAlert: + case eEventNPCScript_FaceWidget: + case eEventNPCScript_FaceWidgetDone: + case eEventNPCScript_GotoWidget: + case eEventNPCScript_GotoWidgetDone: + case eEventNPCScript_AttackWidget: + case eEventNPCScript_AttackWidgetDone: + case eEventNPCScript_FollowWidget: + case eEventNPCScript_PlayAnim: + case eEventNPCScript_PlayAnimDone: + case eEventNPCScript_LeadPlayer: + xSceneID2Name(globals.sceneCur, this->id); + this->flg_misc |= 0x1; + break; + } + } +} + +void zNPCCommon::ParseINI() +{ + NPCConfig* cfg = this->cfg_npc; + + this->TagVerts(); + + for (S32 i = NPC_PARM_MOVERATE; i < NPC_PARM_ENDTAG_INI; i++) + { + en_npcparm pid = (en_npcparm)i; + + switch (pid) + { + case NPC_PARM_ACCEL: + this->GetParm(pid, &cfg->fac_accelMax); + break; + case NPC_PARM_DRIFT: + this->GetParm(pid, &cfg->fac_driftMax); + break; + case NPC_PARM_MASS: + this->GetParm(pid, &cfg->npcMass); + if (cfg->npcMass < 0.5f) + { + cfg->npcMass = 0.5f; + } + cfg->npcMassInv = 1.0f / cfg->npcMass; + break; + case NPC_PARM_TOSSELASTIC: + this->GetParm(pid, &cfg->fac_elastic); + break; + case NPC_PARM_TOSSGRAV: + this->GetParm(pid, &cfg->fac_gravKnock); + break; + case NPC_PARM_HITPOINTS: + this->GetParm(pid, &cfg->pts_damage); + break; + case NPC_PARM_BND_ISBOX: + this->GetParm(pid, &cfg->useBoxBound); + break; + case NPC_PARM_BND_CENTER: + this->GetParm(pid, &cfg->off_bound); + break; + case NPC_PARM_BND_EXTENT: + this->GetParm(pid, &cfg->dim_bound); + break; + case NPC_PARM_MOVERATE: + this->GetParm(pid, &cfg->spd_moveMax); + break; + case NPC_PARM_TURNRATE: + { + F32 fv = RAD2DEG(cfg->spd_turnMax); + this->GetParm(pid, &fv); + cfg->spd_turnMax = DEG2RAD(fv); + break; + } + case NPC_PARM_MODELSCALE: + this->GetParm(pid, &cfg->scl_model); + break; + case NPC_PARM_DETECT_RAD: + this->GetParm(pid, &cfg->rad_detect); + break; + case NPC_PARM_DETECT_HYT: + this->GetParm(pid, &cfg->hyt_detect); + break; + case NPC_PARM_DETECT_OFF: + this->GetParm(pid, &cfg->off_detect); + break; + case NPC_PARM_TIMEFIDGET: + this->GetParm(pid, &cfg->tym_fidget); + break; + case NPC_PARM_TIMEATTACK: + this->GetParm(pid, &cfg->tym_attack); + break; + case NPC_PARM_TIMESTUN: + this->GetParm(pid, &cfg->tym_stun); + break; + case NPC_PARM_TIMEALERT: + this->GetParm(pid, &cfg->tym_alert); + break; + case NPC_PARM_ATTACK_RAD: + this->GetParm(pid, &cfg->rad_attack); + break; + case NPC_PARM_ATTACK_FOV: + { + F32 fv = RAD2DEG(cfg->fov_attack); + this->GetParm(pid, &fv); + cfg->fov_attack = DEG2RAD(fv); + break; + } + case NPC_PARM_SND_RAD: + this->GetParm(pid, &cfg->rad_sound); + break; + case NPC_PARM_ATK_SIZE01: + this->GetParm(pid, &cfg->rad_dmgSize); + break; + case NPC_PARM_ATK_FRAMES01: + case NPC_PARM_ATK_FRAMES01A: + case NPC_PARM_ATK_FRAMES01B: + case NPC_PARM_ATK_FRAMES02: + case NPC_PARM_ATK_FRAMES02A: + case NPC_PARM_ATK_FRAMES02B: + case NPC_PARM_ATK_FRAMES03: + case NPC_PARM_ATK_FRAMES03A: + case NPC_PARM_ATK_FRAMES03B: + this->GetParm(pid, &cfg->animFrameRange[pid - NPC_PARM_ATK_FRAMES01]); + break; + case NPC_PARM_ESTEEM_A: + case NPC_PARM_ESTEEM_B: + case NPC_PARM_ESTEEM_C: + case NPC_PARM_ESTEEM_D: + case NPC_PARM_ESTEEM_E: + this->GetParm(pid, &cfg->cnt_esteem[pid - NPC_PARM_ESTEEM_A]); + break; + case NPC_PARM_SHADOW_CASTDIST: + this->GetParm(pid, &cfg->dst_castShadow); + break; + case NPC_PARM_SHADOW_RADCACHE: + this->GetParm(pid, &cfg->rad_shadowCache); + break; + case NPC_PARM_SHADOW_RADRASTER: + this->GetParm(pid, &cfg->rad_shadowRaster); + break; + case NPC_PARAM_TEST_COUNT: + this->GetParm(pid, &cfg->test_count); + break; + } + } +} + +void zNPCCommon::ParseProps() +{ + for (S32 i = 0x3f; i < 0x42; i++) + { + switch (i) + { + case 0x3f: + MvptReset(NULL); + break; + default: + break; + } + } +} + +void zNPCCommon::CollideReview() +{ + xEntCollis* npccol = this->collis; + xCollis* colrec = &npccol->colls[0]; + S32 i; + S32 hitthings = 0; + + if (!(colrec->flags & k_HIT_IT) && (this->flg_move & 0x2)) + { + this->colFreq = 0; + } + + if (this->drv_data) + { + if ((colrec->flags & k_HIT_IT) && colrec->optr) + { + xEnt* flent = (xEnt*)colrec->optr; + if (this->IsMountableType((en_ZBASETYPE)flent->baseType)) + { + if (!this->drv_data->driver) + { + xEntDriveMount(this->drv_data, flent, 1.0f, colrec); + } + else if (flent != this->drv_data->driver) + { + xEntDriveDismount(this->drv_data, 0.3f); + xEntDriveMount(this->drv_data, flent, 1.0f, colrec); + } + } + } + else if (this->drv_data->driver) + { + xEntDriveDismount(this->drv_data, 0.3f); + } + } + + for (i = npccol->env_sidx; i < npccol->env_eidx; i++) + { + if (!(npccol->colls[i].flags & k_HIT_0x4)) + { + hitthings++; + } + } + + for (i = npccol->stat_sidx; i < npccol->stat_eidx; i++) + { + if (!(npccol->colls[i].flags & k_HIT_0x4)) + { + hitthings++; + } + } + + for (i = npccol->dyn_sidx; i < npccol->dyn_eidx; i++) + { + if (npccol->colls[i].flags & k_HIT_0x4) + { + xBase* base = (xBase*)npccol->colls[i].optr; + if (base->baseType == eBaseTypeButton) + { + zEntButton_Hold((_zEntButton*)base, 0x800); + } + } + hitthings++; + } + + for (i = npccol->npc_sidx; i < npccol->npc_eidx; i++) + { + if (!(npccol->colls[i].flags & k_HIT_0x4)) + { + hitthings++; + } + } + + if (hitthings) + { + S32 cf = (S32)(8.0f * xurand() + 2.0); + colFreq = MIN(colFreq, cf); + } +} + +bool zNPCCommon::IsMountableType(en_ZBASETYPE type) +{ + switch (type) + { + case eBaseTypePlatform: + return true; + break; + default: + return false; + break; + } +} + +void zNPCCommon::SelfDestroy() +{ + xBehaveMgr* bmgr = xBehaveMgr_GetSelf(); + if (psy_instinct != NULL) + { + bmgr->UnSubscribe(psy_instinct); + } + psy_instinct = NULL; +} + +void zNPCCommon::TagVerts() +{ + NPCConfig* cfg = this->cfg_npc; + S32 i; + xVec3 tmp_pos = {}; + F32 vertinfo[4] = {}; + + for (i = 0; i < 20; i++) + { + if (mdlVertToParm[i] != NPC_PARM_NONE) + { + this->GetParm(mdlVertToParm[i], vertinfo); + + tmp_pos.x = vertinfo[0]; + tmp_pos.y = vertinfo[1]; + tmp_pos.z = vertinfo[2]; + + if (xVec3Dot(&tmp_pos, &tmp_pos) > 0.001f) + { + xModelInstance* mdl; + S32 idx_atmoic = (S32)vertinfo[3]; + + if (idx_atmoic < 1) + { + mdl = this->model; + } + else + { + mdl = this->ModelAtomicFind(idx_atmoic, -1, NULL); + } + + if (mdl) + { + iModelTagSetup(&cfg->tag_vert[i], mdl->Data, tmp_pos.x, tmp_pos.y, tmp_pos.z); + + if (xVec3Length2(&tmp_pos)) + { + cfg->flg_vert |= (1 << i); + } + + xSceneID2Name(globals.sceneCur, this->id); + } + } + } + } +} + +S32 zNPCCommon::GetVertPos(en_mdlvert vid, xVec3* pos) +{ + NPCConfig* cfg = cfg_npc; + if (!(cfg->flg_vert & 1 << vid)) + { + return 0; + } + iModelTagEval(model->Data, &cfg->tag_vert[vid], model->Mat, pos); + return 1; +} + +S32 zNPCCommon::IsAttackFrame(F32 tym_anim, S32 series) +{ + S32 result = 0; + NPCConfig* cfg = this->cfg_npc; + + if (!cfg) + return 0; + + xVec3 var_30, var_3C, var_48; + + switch (series) + { + case 0: + case 1: + var_30 = cfg->animFrameRange[0]; + var_3C = cfg->animFrameRange[1]; + var_48 = cfg->animFrameRange[2]; + break; + case 2: + var_30 = cfg->animFrameRange[3]; + var_3C = cfg->animFrameRange[4]; + var_48 = cfg->animFrameRange[5]; + break; + default: + var_30 = cfg->animFrameRange[6]; + var_3C = cfg->animFrameRange[7]; + var_48 = cfg->animFrameRange[8]; + break; + } + + F32 tym = (tym_anim < 0.0f) ? this->AnimTimeCurrent() : tym_anim; + + if (tym >= var_30.x && tym <= var_30.y) + { + result = 1; + } + else if (tym >= var_3C.x && tym <= var_3C.y) + { + result = 2; + } + else if (tym >= var_48.x && tym <= var_48.y) + { + result = 3; + } + + return result; +} + +void zNPCCommon::GiveReward() +{ + S32 i; + U32 s; + NPCConfig* cfg = this->cfg_npc; + U32 shinies[5]; + S32 esteem; + + if (this->SelfType() != NPC_TYPE_ARFDOG) + { + if ((this->SelfType() & 0xFFFFFF00) == 'NTT\0') + { + zCombo_Add(1); + } + else + { + zCombo_Add(3); + } + } + + for (i = 0, s = 0; i < 5; i++) + { + esteem = cfg->cnt_esteem[i]; + if (esteem >= 1) + { + if (esteem == globals.player.g.ShinyValuePurple) + { + shinies[s] = 0; + s++; + } + else if (esteem == globals.player.g.ShinyValueBlue) + { + shinies[s] = 1; + s++; + } + else if (esteem == globals.player.g.ShinyValueGreen) + { + shinies[s] = 2; + s++; + } + else if (esteem == globals.player.g.ShinyValueYellow) + { + shinies[s] = 3; + s++; + } + else if (esteem == globals.player.g.ShinyValueRed) + { + shinies[s] = 4; + s++; + } + else + { + shinies[i] = 4; + s++; + break; + } + } + } + + if (s) + { + zEntPickup_SpawnNRewards(shinies, s, *this->Pos()); + } + + this->PlayerKiltMe(); +} + +void zNPCPlyrSnd_Reset() +{ + g_tmr_talkless = 10.0f; +} + +void zNPCPlyrSnd_Update(F32 dt) +{ + g_tmr_talkless = MAX(-1.0f, g_tmr_talkless - dt); +} + +void zNPCCommon::PlayerKiltMe() +{ + en_xEventTags r30 = eEventUnknown; + S32 r31 = this->SelfType(); + + if (!SomethingWonderful() && g_tmr_talkless < 0.0f) + { + g_tmr_talkless = 3.0f + (xurand() - 0.5f) * 0.25f * 3.0f; + + if ((r31 & 0xFFFFFF00) == 'NTR\0') + { + r30 = eEventSituationDestroyedRobot; + } + else if ((r31 & 0xFFFFFF00) == 'NTT\0') + { + r30 = eEventSituationDestroyedTiki; + } + + if (r30 != eEventUnknown) + { + zEntEvent(this, &globals.player.ent, r30); + } + } +} + +void zNPCCommon::ISeePlayer() //NONMATCH("https://decomp.me/scratch/M08oY") +{ + en_xEventTags ven = eEventUnknown; + + if (!SomethingWonderful() && g_tmr_talkless < 0.0f) + { + g_tmr_talkless = 3.0f + (xurand() - 0.5f) * 0.25f * 3.0f; + + switch (this->SelfType()) + { + //case NPC_TYPE_UNKNOWN: + //case NPC_TYPE_BASIC: + //case NPC_TYPE_COMMON: + case NPC_TYPE_AMBIENT: + case NPC_TYPE_VILLAGER: + case NPC_TYPE_ROBOT: + case NPC_TYPE_BOSS: + case NPC_TYPE_TEST: + case NPC_TYPE_BADGUY: + case NPC_TYPE_JELLYPINK: + case NPC_TYPE_JELLYBLUE: + case NPC_TYPE_KINGNEPTUNE: + case NPC_TYPE_MIMEFISH: + //case NPC_TYPE_COW: + break; + case NPC_TYPE_TIKI_WOOD: + ven = eEventSituationSeeWoodTiki; + break; + case NPC_TYPE_TIKI_LOVEY: + ven = eEventSituationSeeLoveyTiki; + break; + case NPC_TYPE_TIKI_QUIET: + ven = eEventSituationSeeShhhTiki; + break; + case NPC_TYPE_TIKI_THUNDER: + ven = eEventSituationSeeThunderTiki; + break; + case NPC_TYPE_TIKI_STONE: + ven = eEventSituationSeeStoneTiki; + break; + case NPC_TYPE_FISH: + //case NPC_TYPE_FISH_MALE: + //case NPC_TYPE_FISH_FEMALE: + //case NPC_TYPE_FISH_ELDER: + //case NPC_TYPE_FISH_ELDESS: + //case NPC_TYPE_FISH_BOY: + //case NPC_TYPE_FISH_GIRL: + //case NPC_TYPE_BALLOONBOY: + //case NPC_TYPE_GARY: + //case NPC_TYPE_SQUIDWARD: + case NPC_TYPE_SQUIDWARD_MUSIC: + case NPC_TYPE_SQUIDWARD_BANDAID: + //case NPC_TYPE_DUTCHMAN_NSB: + //case NPC_TYPE_SANDYBIKINI: + //case NPC_TYPE_SANDYNPC: + //case NPC_TYPE_PATNPC: + //case NPC_TYPE_BOBNPC: + //case NPC_TYPE_PLANKNPC: + //case NPC_TYPE_MRKRABS: + //case NPC_TYPE_MSPUFFS: + //case NPC_TYPE_LARRY: + //case NPC_TYPE_BUBBUDDY: + //case NPC_TYPE_NEWSFISH: + case NPC_TYPE_NEWSFISHTV: + //case NPC_TYPE_MOTORIST: + //case NPC_TYPE_MERMANCHAIR: + //case NPC_TYPE_MERMAN: + case NPC_TYPE_BARNACLEBOY: + //case NPC_TYPE_WORM: + break; + case NPC_TYPE_HAMMER: + case NPC_TYPE_HAMSPIN: + ven = eEventSituationSeeHammer; + break; + case NPC_TYPE_TARTAR: + ven = eEventSituationSeeTarTar; + break; + case NPC_TYPE_GLOVE: + ven = eEventSituationSeeGLove; + break; + case NPC_TYPE_MONSOON: + ven = eEventSituationSeeMonsoon; + break; + case NPC_TYPE_SLEEPY: + ven = eEventSituationSeeSleepyTime; + break; + case NPC_TYPE_ARFDOG: + break; + case NPC_TYPE_ARFARF: + ven = eEventSituationSeeArf; + break; + case NPC_TYPE_CHUCK: + break; + case NPC_TYPE_TUBELET: + case NPC_TYPE_TUBESLAVE: + ven = eEventSituationSeeTubelets; + break; + case NPC_TYPE_SLICK: + ven = eEventSituationSeeSlick; + break; + case NPC_TYPE_FODDER: + case NPC_TYPE_FODBOMB: + case NPC_TYPE_FODBZZT: + case NPC_TYPE_CHOMPER: + case NPC_TYPE_CRITTER: + ven = eEventSituationSeeFodder; + break; + case NPC_TYPE_DUPLOTRON: + break; + case NPC_TYPE_KINGJELLY: + ven = eEventSituationSeeKingJellyfish; + break; + case NPC_TYPE_DUTCHMAN: + ven = eEventSituationSeeDutchman; + break; + case NPC_TYPE_PRAWN: + ven = eEventSituationSeePrawn; + break; + case NPC_TYPE_BOSSSANDY: + ven = eEventSituationSeeSandyBoss; + break; + case NPC_TYPE_BOSSPAT: + ven = eEventSituationSeePatrickBoss; + break; + case NPC_TYPE_BOSS_SB1: + case NPC_TYPE_BOSSBOBBY: + ven = eEventSituationSeeSpongeBobBoss; + break; + case NPC_TYPE_BOSSPLANKTON: + ven = eEventSituationSeeRobotPlankton; + break; + //case NPC_TYPE_BADGUYMEDIUM: + // break; + } + + if (ven != eEventUnknown) + { + zEntEvent(this, &globals.player.ent, ven); + } + } +} + +void zNPCCommon::ConfigSceneDone() +{ + g_ncfghead = 0; +} + +NPCConfig* zNPCCommon::ConfigCreate(U32 modelID) +{ + NPCConfig* cfg = (NPCConfig*)xMemAllocSize(sizeof(NPCConfig)); + memset(cfg, 0, sizeof(NPCConfig)); + + cfg->modelID = modelID; + + if (!g_ncfghead) + { + g_ncfghead = cfg; + } + else + { + cfg->Insert(g_ncfghead); + } + + return cfg; +} + +NPCConfig* zNPCCommon::ConfigFind(U32 modelID) +{ + NPCConfig* cfg = NULL; + + for (NPCConfig* r3 = g_ncfghead; r3 != NULL; r3 = r3->Next()) + { + if (r3->modelID == modelID) + { + cfg = r3; + break; + } + } + + return cfg; +} + +void zNPCCommon::GetParm(en_npcparm pid, S32* val) +{ + this->GetParm(pid, (void*)val); +} + +void zNPCCommon::GetParm(en_npcparm pid, F32* val) +{ + this->GetParm(pid, (void*)val); +} + +void zNPCCommon::GetParm(en_npcparm pid, xVec3* val) +{ + this->GetParm(pid, (void*)val); +} + +void zNPCCommon::GetParm(en_npcparm pid, zMovePoint** val) +{ + this->GetParm(pid, (void*)val); +} + +void zNPCCommon::GetParm(en_npcparm pid, void* val) //NONMATCH("https://decomp.me/scratch/dg7eV") +{ + char** names = g_strz_params; + xModelAssetParam* pmdata = this->parmdata; + U32 pmsize = this->pdatsize; + + this->GetParmDefault(pid, val); + + switch (pid) + { + case NPC_PARM_BND_ISBOX: + case NPC_PARM_HITPOINTS: + case NPC_PARM_ESTEEM_A: + case NPC_PARM_ESTEEM_B: + case NPC_PARM_ESTEEM_C: + case NPC_PARM_ESTEEM_D: + case NPC_PARM_ESTEEM_E: + case NPC_PARAM_TEST_COUNT: + if (pmdata && pmsize) + { + *(S32*)val = zParamGetInt(pmdata, pmsize, names[pid], *(S32*)val); + } + break; + case NPC_PARM_MOVERATE: + case NPC_PARM_TURNRATE: + case NPC_PARM_ACCEL: + case NPC_PARM_DRIFT: + case NPC_PARM_MASS: + case NPC_PARM_TOSSGRAV: + case NPC_PARM_TOSSELASTIC: + case NPC_PARM_DETECT_RAD: + case NPC_PARM_DETECT_HYT: + case NPC_PARM_DETECT_OFF: + case NPC_PARM_ATTACK_RAD: + case NPC_PARM_ATTACK_FOV: + case NPC_PARM_SND_RAD: + case NPC_PARM_TIMEFIDGET: + case NPC_PARM_TIMEATTACK: + case NPC_PARM_TIMESTUN: + case NPC_PARM_TIMEALERT: + case NPC_PARM_ATK_SIZE01: + case NPC_PARM_SHADOW_CASTDIST: + case NPC_PARM_SHADOW_RADCACHE: + case NPC_PARM_SHADOW_RADRASTER: + if (pmdata && pmsize) + { + *(F32*)val = zParamGetFloat(pmdata, pmsize, names[pid], *(F32*)val); + } + break; + case NPC_PARM_BND_CENTER: + case NPC_PARM_BND_EXTENT: + case NPC_PARM_MODELSCALE: + case NPC_PARM_ATK_FRAMES01: + case NPC_PARM_ATK_FRAMES01A: + case NPC_PARM_ATK_FRAMES01B: + case NPC_PARM_ATK_FRAMES02: + case NPC_PARM_ATK_FRAMES02A: + case NPC_PARM_ATK_FRAMES02B: + case NPC_PARM_ATK_FRAMES03: + case NPC_PARM_ATK_FRAMES03A: + case NPC_PARM_ATK_FRAMES03B: + if (pmdata && pmsize) + { + zParamGetVector(pmdata, pmsize, names[pid], *(xVec3*)val, (xVec3*)val); + } + break; + case NPC_PARM_VTX_ATTACKBASE: + case NPC_PARM_VTX_ATTACK: + case NPC_PARM_VTX_ATTACK1: + case NPC_PARM_VTX_ATTACK2: + case NPC_PARM_VTX_ATTACK3: + case NPC_PARM_VTX_ATTACK4: + case NPC_PARM_VTX_EYEBALL: + case NPC_PARM_VTX_DMGSMOKEA: + case NPC_PARM_VTX_DMGSMOKEB: + case NPC_PARM_VTX_DMGSMOKEC: + case NPC_PARM_VTX_DMGFLAMEA: + case NPC_PARM_VTX_DMGFLAMEB: + case NPC_PARM_VTX_DMGFLAMEC: + case NPC_PARM_VTX_PROPEL: + case NPC_PARM_VTX_EXHAUST: + case NPC_PARM_VTX_GEN01: + case NPC_PARM_VTX_GEN02: + case NPC_PARM_VTX_GEN03: + case NPC_PARM_VTX_GEN04: + case NPC_PARM_VTX_GEN05: + zParamGetFloatList(pmdata, pmsize, names[pid], 4, NULL, (F32*)val); + break; + case NPC_PARM_FIRSTMVPT: + if (this->npcass->movepoint) + { + zMovePoint* mvpt = zMovePoint_From_xAssetID(this->npcass->movepoint); + if (mvpt) + { + *(zMovePoint**)val = mvpt; + } + } + break; + case NPC_PARM_BOGUSSHARE: + if (pmdata && pmsize) + { + *(S32*)val = zParamGetInt(pmdata, pmsize, names[pid], *(S32*)val); + } + break; + case NPC_PARM_NONE: + case NPC_PARM_ENDTAG_INI: + case NPC_PARM_ENDTAG_PROPS: + case NPC_PARM_ENDTAG_SHARE: + break; + } +} + +void zNPCCommon::GetParmDefault(en_npcparm pid, void* val) +//NONMATCH("https://decomp.me/scratch/mNHLS") +{ + // Should be a S32? + S32 result = 1; + S32* ivp = (S32*)val; + F32* fvp = (F32*)val; + F32* fvlist = (F32*)val; + xVec3* vec = (xVec3*)val; + zMovePoint** mvpt = (zMovePoint**)val; + + switch (pid) + { + case NPC_PARM_HITPOINTS: + *ivp = 1; + break; + case NPC_PARM_MOVERATE: + *fvp = 2.0f; + break; + case NPC_PARM_TURNRATE: + *fvp = 90.0f; + break; + case NPC_PARM_ACCEL: + *fvp = 1.0f; + break; + case NPC_PARM_DRIFT: + *fvp = 0.0f; + break; + case NPC_PARM_MASS: + *fvp = 1.0f; + break; + case NPC_PARM_TOSSGRAV: + *fvp = 25.0f; + break; + case NPC_PARM_TOSSELASTIC: + *fvp = 0.5f; + break; + case NPC_PARM_BND_ISBOX: + *ivp = 0; + break; + case NPC_PARM_BND_CENTER: + xVec3Copy(vec, &g_O3); + break; + case NPC_PARM_BND_EXTENT: + xVec3Copy(vec, &g_O3); + break; + case NPC_PARM_DETECT_RAD: + *fvp = 3.0f; + break; + case NPC_PARM_DETECT_HYT: + *fvp = 6.0f; + break; + case NPC_PARM_DETECT_OFF: + *fvp = -2.0f; + break; + case NPC_PARM_ATTACK_RAD: + *fvp = 5.0f; + break; + case NPC_PARM_ATTACK_FOV: + *fvp = 60.0f; + break; + case NPC_PARM_SND_RAD: + *fvp = 30.0f; + break; + case NPC_PARM_ESTEEM_A: + case NPC_PARM_ESTEEM_B: + case NPC_PARM_ESTEEM_C: + case NPC_PARM_ESTEEM_D: + case NPC_PARM_ESTEEM_E: + *ivp = 0; + break; + case NPC_PARM_SHADOW_CASTDIST: + case NPC_PARM_SHADOW_RADCACHE: + case NPC_PARM_SHADOW_RADRASTER: + *fvp = -1.0f; + break; + case NPC_PARM_ATK_SIZE01: + *fvp = 0.5f; + break; + case NPC_PARM_ATK_FRAMES01: + vec->x = -1.0f; + vec->y = 100.0f; + vec->z = 0.0f; + break; + case NPC_PARM_ATK_FRAMES01A: + case NPC_PARM_ATK_FRAMES01B: + case NPC_PARM_ATK_FRAMES02: + case NPC_PARM_ATK_FRAMES02A: + case NPC_PARM_ATK_FRAMES02B: + case NPC_PARM_ATK_FRAMES03: + case NPC_PARM_ATK_FRAMES03A: + case NPC_PARM_ATK_FRAMES03B: + vec->x = -1.0f; + vec->y = -2.0f; + vec->z = 0.0f; + break; + case NPC_PARM_MODELSCALE: + xVec3Copy(vec, &g_O3); + break; + case NPC_PARM_TIMEFIDGET: + *fvp = 15.0f; + break; + case NPC_PARM_TIMEATTACK: + *fvp = 15.0f; + break; + case NPC_PARM_TIMESTUN: + *fvp = 5.0f; + break; + case NPC_PARM_TIMEALERT: + *fvp = 5.0f; + break; + case NPC_PARAM_TEST_COUNT: + *ivp = 1; + break; + case NPC_PARM_VTX_ATTACKBASE: + case NPC_PARM_VTX_ATTACK: + case NPC_PARM_VTX_ATTACK1: + case NPC_PARM_VTX_ATTACK2: + case NPC_PARM_VTX_ATTACK3: + case NPC_PARM_VTX_ATTACK4: + case NPC_PARM_VTX_EYEBALL: + case NPC_PARM_VTX_DMGSMOKEA: + case NPC_PARM_VTX_DMGSMOKEB: + case NPC_PARM_VTX_DMGSMOKEC: + case NPC_PARM_VTX_DMGFLAMEA: + case NPC_PARM_VTX_DMGFLAMEB: + case NPC_PARM_VTX_DMGFLAMEC: + case NPC_PARM_VTX_PROPEL: + case NPC_PARM_VTX_EXHAUST: + case NPC_PARM_VTX_GEN01: + case NPC_PARM_VTX_GEN02: + case NPC_PARM_VTX_GEN03: + case NPC_PARM_VTX_GEN04: + case NPC_PARM_VTX_GEN05: + fvlist[0] = 0.0f; + fvlist[1] = 0.0f; + fvlist[2] = 0.0f; + fvlist[3] = 0.0f; + break; + case NPC_PARM_FIRSTMVPT: + *mvpt = NULL; + break; + case NPC_PARM_ENDTAG_INI: + case NPC_PARM_ENDTAG_PROPS: + case NPC_PARM_ENDTAG_SHARE: + result = 0; + break; + default: + result = 0; + break; + } + + //return result; +} + +void zNPCCommon_WonderReset() +{ + g_isConversation = 0; + g_flg_wonder = 0; +} + +U32 zNPCCommon::CanDoSplines() +{ + bool retval = false; + if ((npcset.useNavSplines) && ((flg_move)&8)) + { + retval = true; + } + return retval; +} + +zMovePoint* zNPCCommon::FirstAssigned() +{ + zMovePoint* nav_first = NULL; + zNPCCommon::GetParm(NPC_PARM_FIRSTMVPT, &nav_first); + return nav_first; +} + +void zNPCCommon::MvptReset(zMovePoint* nav_goto) //NONMATCH("https://decomp.me/scratch/lhUW9") +{ + if (nav_goto) + { + this->nav_dest = nav_goto; + } + else + { + this->GetParm(NPC_PARM_FIRSTMVPT, &this->nav_dest); + } + + this->nav_past = this->nav_dest; + this->nav_curr = this->nav_dest; + this->nav_lead = this->nav_dest; + this->spl_mvptspline = NULL; + this->len_mvptspline = 0.0f; + this->dst_curspline = 0.0f; +} + +S32 zNPCCommon::MvptCycle() //NONMATCH("https://decomp.me/scratch/CGooj") +{ + zMovePoint* nav_tmp = NULL; + + this->spl_mvptspline = NULL; + this->len_mvptspline = 0.0f; + this->dst_curspline = 0.0f; + + if (!this->nav_curr) + { + this->GetParm(NPC_PARM_FIRSTMVPT, &this->nav_curr); + nav_tmp = this->nav_curr; + } + else if (this->nav_curr && this->nav_dest) + { + zMovePointGetNext(this->nav_dest, this->nav_curr, &nav_tmp, NULL); + } + else if (this->nav_curr) + { + zMovePointGetNext(this->nav_curr, NULL, &nav_tmp, NULL); + } + + if (this->nav_curr) + { + this->nav_past = this->nav_curr; + } + + if (this->nav_dest) + { + this->nav_curr = this->nav_dest; + } + + this->nav_dest = nav_tmp; + + if (this->CanDoSplines() && this->nav_dest && this->nav_dest->HasSpline()) + { + this->spl_mvptspline = this->nav_dest->spl; + + while (this->nav_dest->asset->bezIndex != 0) + { + this->nav_dest = (zMovePoint*)this->nav_dest->nodes[0]; + } + + this->len_mvptspline = xSpline3_ArcTotal(this->spl_mvptspline); + } + + if (this->nav_dest) + { + zMovePointGetNext(this->nav_dest, this->nav_curr, &this->nav_lead, NULL); + } + + return (this->nav_dest != NULL); +} + +S32 zNPCCommon::HaveLOSToPos(xVec3* pos, F32 dist, xScene* xscn, xBase* tgt, xCollis* colCallers) +//NONMATCH("https://decomp.me/scratch/wxm2S") +{ + S32 result; + xRay3 ray = {}; + xVec3 mypos = {}; + + xCollis* colrec; + if (colCallers) + { + colrec = colCallers; + } + else + { + static xCollis localCollis = { k_HIT_0xF00 | k_HIT_CALC_HDNG }; + memset(&localCollis, 0, sizeof(localCollis)); + localCollis.flags = k_HIT_0xF00 | k_HIT_CALC_HDNG; + + colrec = &localCollis; + } + + this->DBG_PStatCont((en_npcperf)1); + this->DBG_PStatOn((en_npcperf)2); + + if (!this->GetVertPos(NPC_MDLVERT_LOSEYEBALL, &mypos)) + { + xVec3Copy(&mypos, xEntGetCenter(this)); + } + + NPCC_xBoundAway(&this->bound); + + ray.min_t = 0.0f; + ray.max_t = dist; + xVec3Sub(&ray.dir, pos, &mypos); + xVec3Normalize(&ray.dir, &ray.dir); + xVec3Copy(&ray.origin, &mypos); + ray.flags = XRAY3_USE_MIN | XRAY3_USE_MAX; + xRayHitsScene(xscn, &ray, colrec); + + NPCC_xBoundBack(&this->bound); + + if (!(colrec->flags & k_HIT_IT)) + { + result = 1; + } + else if (colrec->dist > dist) + { + result = 1; + } + else if (tgt && colrec->oid) + { + if (tgt->id == colrec->oid) + { + result = 1; + } + else + { + result = 0; + } + } + else + { + result = 0; + } + + if (this->DBG_IsNormLog((en_npcdcat)13, 2)) + { + if (result) + { + xDrawSetColor(g_GREEN); + } + else + { + xDrawSetColor(g_NEON_BLUE); + } + + xDrawLine(&mypos, pos); + } + + this->DBG_PStatCont((en_npcperf)2); + this->DBG_PStatOn((en_npcperf)1); + + return result; +} + +xModelInstance* zNPCCommon::ModelAtomicHide(S32 index, xModelInstance* mdl) +{ + xModelInstance* minst = mdl ? mdl : this->ModelAtomicFind(index, -1, NULL); + if (!minst) + return minst; + + minst->Flags &= ~0x1; + + return minst; +} + +xModelInstance* zNPCCommon::ModelAtomicShow(S32 index, xModelInstance* mdl) +{ + xModelInstance* minst = mdl ? mdl : this->ModelAtomicFind(index, -1, NULL); + if (!minst) + return minst; + + minst->Flags |= 0x2; + minst->Flags |= 0x1; + + return minst; +} + +xModelInstance* zNPCCommon::ModelAtomicFind(S32 index, S32 idx_prev, xModelInstance* mdl_prev) +{ + xModelInstance* da_atomic = NULL; + xModelInstance* minst = mdl_prev; + S32 midx = 0; + + if (minst && idx_prev >= 0) + { + midx = idx_prev; + } + else + { + minst = this->model; + } + + while (minst) + { + if (midx == index) + { + da_atomic = minst; + break; + } + minst = minst->Next; + midx++; + } + + return da_atomic; +} + +void zNPCCommon::ModelScaleSet(F32 x, F32 y, F32 z) +{ + xModelInstance* minst = this->model; + + while (minst) + { + minst->Scale.x = x; + minst->Scale.y = y; + minst->Scale.z = z; + minst = minst->Next; + } +} + +S32 zNPCCommon::AnimStart(U32 animID, S32 forceRestart) +{ + static S32 dumptable = 0; + if (dumptable) + { + dumptable = 0; + this->AnimGetTable(); + } + + xAnimState* r3_ = this->AnimCurState(); + if (r3_ && r3_->ID == animID && !forceRestart) + { + return r3_->ID; + } + + xAnimTable* r3 = this->AnimGetTable(); + xAnimTransition* da_tran = r3->TransitionList; + + while (da_tran) + { + if (da_tran->Dest->ID == animID) + { + break; + } + da_tran = da_tran->Next; + } + + if (da_tran) + { + xAnimPlayStartTransition(this->model->Anim, da_tran); + } + else + { + xSceneID2Name(globals.sceneCur, this->id); + } + + if (da_tran) + { + return da_tran->Dest->ID; + } + + return 0; +} + +void zNPCCommon::AnimSetState(U32 animID, F32 time) +{ + xAnimTable* r3 = this->AnimGetTable(); + xAnimState* state = xAnimTableGetStateID(r3, animID); + + xAnimPlaySetState(this->model->Anim->Single, state, time); +} + +xAnimState* zNPCCommon::AnimFindState(U32 animID) +{ + xAnimTable* r3 = this->AnimGetTable(); + return xAnimTableGetStateID(r3, animID); +} + +xAnimSingle* zNPCCommon::AnimCurSingle() +{ + if (!this->model->Anim && (this->SelfType() & 0xFFFFFF00) == 'NTT\0') + { + return NULL; + } + + return this->model->Anim->Single; +} + +xAnimState* zNPCCommon::AnimCurState() +{ + if (!this->model->Anim && (this->SelfType() & 0xFFFFFF00) == 'NTT\0') + { + return NULL; + } + + return this->model->Anim->Single->State; +} + +zNPCSettings* zNPCSettings_Find(U32 id) +{ + zNPCSettings* set = NULL; + U32 size = 0; + + if (id) + { + set = (zNPCSettings*)xSTFindAsset(id, &size); + } + + if (!set) + { + set = g_dflt_npcsettings; + } + + return set; +} + +void zNPCCommon::Vibrate(F32 ds2_cur, F32 ds2_max) //NONMATCH("https://decomp.me/scratch/A5HIP") +{ + F32 rat = ds2_cur / MAX(ds2_max, 1.0f); + + if (rat < 0.4f) + { + this->Vibrate(NPC_VIBE_HARD, -1.0f); + } + else if (rat < 0.7f) + { + this->Vibrate(NPC_VIBE_NORM, -1.0f); + } + else if (rat < 1.0f) + { + this->Vibrate(NPC_VIBE_SOFT, -1.0f); + } +} + +void zNPCCommon::Vibrate(en_npcvibe vibe, F32 duration) +{ + _tagRumbleType typ_rum; + F32 tym_rum; + + switch (vibe) + { + case NPC_VIBE_BUILD_A: + tym_rum = 0.05f; + typ_rum = eRumble_Light; + break; + case NPC_VIBE_BUILD_B: + tym_rum = 0.05f; + typ_rum = eRumble_Medium; + break; + case NPC_VIBE_BUILD_C: + tym_rum = 0.05f; + typ_rum = eRumble_Heavy; + break; + case NPC_VIBE_SOFT: + tym_rum = 0.1f; + typ_rum = eRumble_Light; + break; + case NPC_VIBE_NORM: + tym_rum = 0.25f; + typ_rum = eRumble_Medium; + break; + case NPC_VIBE_HARD: + tym_rum = 0.45f; + typ_rum = eRumble_Heavy; + break; + default: + tym_rum = 0.0f; + typ_rum = eRumble_Medium; + zPadAddRumble(eRumble_Medium, 0.4f, 0, 0); + break; + } + + if (duration > 0.0f) + { + tym_rum = duration; + } + //return retval; +} + +U32 zNPCCommon::AnimCurStateID() +{ + xAnimState* state = AnimCurState(); + if (state != NULL) + { + return state->ID; + } + else + { + return 0; + } +} + +F32 zNPCCommon::AnimDuration(xAnimState* ast) +{ + if (ast == 0) + { + ast = AnimCurState(); + } + return (ast == 0) ? 0.0f : ast->Data->Duration; +} + +F32 zNPCCommon::AnimTimeRemain(xAnimState* ast) +{ + return (AnimDuration(ast) - AnimTimeCurrent()); +} + +F32 zNPCCommon::AnimTimeCurrent() +{ + return model->Anim->Single->Time; +} + +void zNPCSettings_MakeDummy() //NONMATCH("https://decomp.me/scratch/amPtL") +{ + static zNPCSettings dum; + dum.id = 0xFEEDCAFE; + dum.baseType = eBaseTypeNPCSettings; + dum.linkCount = 0; + dum.baseFlags = ((U16)(1 << 0)); + dum.type = 0xBAD0CACA; + dum.version = 2; + dum.handle = 0; + dum.basisType = NPCP_BASIS_NONE; + dum.allowDetect = 1; + dum.allowWander = 1; + dum.allowPatrol = 1; + dum.reduceCollide = 0; + dum.useNavSplines = 1; + dum.allowChase = 1; + dum.allowAttack = 1; + dum.assumeLOS = 0; + dum.assumeFOV = 0; + dum.duploWaveMode = NPCP_DUPOWAVE_CONTINUOUS; + dum.duploSpawnLifeMax = -1; + dum.duploSpawnDelay = 5.0f; + + g_dflt_npcsettings = &dum; } xVec3* zNPCCommon::MatPosSet(xVec3* pos) diff --git a/src/SB/Game/zNPCTypeCommon.h b/src/SB/Game/zNPCTypeCommon.h index 9ce4342c6..36794fdec 100644 --- a/src/SB/Game/zNPCTypeCommon.h +++ b/src/SB/Game/zNPCTypeCommon.h @@ -8,10 +8,21 @@ #include "xBehaveMgr.h" #include "xEnt.h" #include "xSFX.h" +#include "xstransvc.h" +#include "xDraw.h" #include "zNPCSndTable.h" #include "zMovePoint.h" #include "zShrapnel.h" +#include "zNPCMessenger.h" +#include "zNPCGoals.h" +#include "zGrid.h" +#include "iCollide.h" +#include "zEntButton.h" +#include "zCombo.h" + +#define XRAY3_USE_MIN (1 << 10) +#define XRAY3_USE_MAX (1 << 11) typedef struct NPCMsg; @@ -401,7 +412,10 @@ struct zNPCCommon : xNPCBasic //Size of zNPCCommon: 0x2A0 F32 ThrottleAccel(F32 dt, S32 speedup, F32 pct_max); F32 ThrottleAdjust(F32 dt, F32 spd_want, F32 accel); - F32 BoundAsRadius(int useCfg); + void InitBounds(); + F32 BoundAsRadius(int useCfg) const; + void ConvertHitEvent(xBase* from, xBase* to, U32 toEvent, const F32* toParam, + xBase* toParamWidget, S32* handled); void VelStop(); static void ConfigSceneDone(); U32 LassoInit(); @@ -418,6 +432,7 @@ struct zNPCCommon : xNPCBasic //Size of zNPCCommon: 0x2A0 bool IsMountableType(en_ZBASETYPE type); void MvptReset(zMovePoint* nav_goto); S32 MvptCycle(); + void TagVerts(); S32 HaveLOSToPos(xVec3*, float, xScene*, xBase*, xCollis*); void ModelScaleSet(F32 x, F32 y, F32 z); void ModelScaleSet(F32 unk); @@ -426,18 +441,33 @@ struct zNPCCommon : xNPCBasic //Size of zNPCCommon: 0x2A0 xModelInstance* ModelAtomicHide(int index, xModelInstance* mdl); xModelInstance* ModelAtomicShow(int index, xModelInstance* mdl); S32 AnimStart(U32 animID, S32 forceRestart); + void AnimSetState(U32 animID, F32 time); xAnimState* AnimFindState(U32 animID); xAnimState* AnimCurState(); xAnimSingle* AnimCurSingle(); U32 AnimCurStateID(); + void ISeePlayer(); + NPCConfig* ConfigCreate(U32 modelID); + NPCConfig* ConfigFind(U32 modelID); + void GetParm(en_npcparm pid, S32* val); + void GetParm(en_npcparm pid, F32* val); + void GetParm(en_npcparm pid, xVec3* val); + void GetParm(en_npcparm pid, zMovePoint** val); + S32 HasSpline(); U32 CanDoSplines(); + S32 IsAttackFrame(F32 tym_anim, S32 series); void GiveReward(); + void PlayerKiltMe(); S32 SndPlayFromSFX(xSFX* sfx, U32* sid_played); S32 SndPlayRandom(en_NPC_SOUND sndtype); + //U32 SndStart(U32 aid_toplay, NPCSndProp* sprop, F32 radius); S32 SndChanIsBusy(S32 flg_chan); + void SndKillSounds(S32 flg_chan, S32 all); + S32 SndQueUpdate(F32 dt); S32 LassoUseGuides(S32 idx_grabmdl, S32 idx_holdmdl); S32 GetVertPos(en_mdlvert vid, xVec3* pos); void Vibrate(en_npcvibe vibe, F32 duration); + void Vibrate(F32 vibe, F32 duration); void AddScripting(xPsyche* psy, S32 (*eval_script)(xGoal*, void*, en_trantype*, F32, void*), S32 (*eval_playanim)(xGoal*, void*, en_trantype*, F32, void*), S32 (*eval_attack)(xGoal*, void*, en_trantype*, F32, void*), @@ -646,10 +676,33 @@ void NPCC_BuildStandardAnimTran(xAnimTable* table, char** namelist, S32* ourAnim F32 blend); void zNPCCommon_Timestep(xScene* xscn, F32 dt); +xFactoryInst* ZNPC_Create_Common(S32 who, RyzMemGrow* grow, void*); +void ZNPC_Destroy_Common(xFactoryInst* inst); +void ZNPC_Common_Startup(); +void ZNPC_Common_Shutdown(); +void zNPCCommon_ScenePrepare(); +void zNPCCommon_SceneFinish(); +void zNPCCommon_SceneReset(); +void zNPCCommon_ScenePostInit(); +void zNPCCommon_Timestep(xScene*, F32 dt); +void zNPCSettings_MakeDummy(); +zNPCSettings* zNPCSettings_Find(U32); +S32 NPCC_NPCIsConversing(); +void zNPCCommon_WonderReset(); xAnimTable* ZNPC_AnimTable_Common(); xAnimTable* ZNPC_AnimTable_LassoGuide(); -S32 NPCC_NPCIsConversing(); +void NPCC_BuildStandardAnimTran(xAnimTable* table, char** namelist, S32* ourAnims, S32 idx_dflt, + F32 blend); void zNPCCommon_EjectPhlemOnPawz(); U32 xSndIsPlaying(U32 assetID, U32 parid); +// move to messenger? + +void zNPCMsg_AreaNotify(zNPCCommon* sender, en_NPC_MSG_ID msgid, F32 rad, S32 filter, + en_NPCTYPES toNPCType); + +void zNPCMsg_SendMsg(en_NPC_MSG_ID msgevent, zNPCCommon* npc_sendto); +void zNPCMsg_SendMsg(NPCMsg* inmsg, zNPCCommon* npc_sendto); +void zNPCMsg_SendMsg(NPCMsg* inmsg, F32 delay, zNPCCommon* npc_sendto); + #endif From 17f6f58842c775502ba7fb784c5626619b2336a2 Mon Sep 17 00:00:00 2001 From: Colin Miller Date: Sun, 13 Jul 2025 23:33:03 -0400 Subject: [PATCH 02/13] build fix --- src/SB/Core/x/xEntMotion.cpp | 5 ----- src/SB/Game/zNPCSupport.cpp | 4 ++-- src/SB/Game/zNPCTypeCommon.h | 1 + 3 files changed, 3 insertions(+), 7 deletions(-) diff --git a/src/SB/Core/x/xEntMotion.cpp b/src/SB/Core/x/xEntMotion.cpp index 39a84b177..c294f14c4 100644 --- a/src/SB/Core/x/xEntMotion.cpp +++ b/src/SB/Core/x/xEntMotion.cpp @@ -284,11 +284,6 @@ void xEntMotionMove(xEntMotion*, xScene*, F32, xEntFrame*) { } -F32 xSpline3_ArcTotal(xSpline3*) -{ - return 0.0f; -} - void xQuatCopy(xQuat* a, const xQuat* b) { a->s = b->s; diff --git a/src/SB/Game/zNPCSupport.cpp b/src/SB/Game/zNPCSupport.cpp index 29dfb2eec..7e8fdc0fc 100644 --- a/src/SB/Game/zNPCSupport.cpp +++ b/src/SB/Game/zNPCSupport.cpp @@ -674,9 +674,9 @@ void NPCC_ang_toXZDir(F32 angle, xVec3* dir) dir->z = icos(angle); } -void NPCC_dir_toXZAng(const xVec3* vec) +F32 NPCC_dir_toXZAng(const xVec3* vec) { - xatan2(vec->x, vec->z); + return xatan2(vec->x, vec->z); } void NPCC_aimMiss(xVec3* dir_aim, xVec3* pos_src, xVec3* pos_tgt, F32 dst_miss, xVec3* pos_miss) diff --git a/src/SB/Game/zNPCTypeCommon.h b/src/SB/Game/zNPCTypeCommon.h index 36794fdec..3cbb0481d 100644 --- a/src/SB/Game/zNPCTypeCommon.h +++ b/src/SB/Game/zNPCTypeCommon.h @@ -20,6 +20,7 @@ #include "iCollide.h" #include "zEntButton.h" #include "zCombo.h" +#include "zNPCTypes.h" #define XRAY3_USE_MIN (1 << 10) #define XRAY3_USE_MAX (1 << 11) From 328db99cfbe1749f343359464f9f37743e9e2fe3 Mon Sep 17 00:00:00 2001 From: Colin Miller Date: Tue, 12 Aug 2025 21:37:21 -0400 Subject: [PATCH 03/13] zNPCTypeBossPlankton & zNPCTypeBossSB2 work (#589) * ported zNPCSupport code, zNPCTypeCommon * build fix * BossSB2 & BossPlankton --- src/SB/Core/x/xDecal.h | 2 +- src/SB/Core/x/xLaserBolt.h | 35 ++- src/SB/Game/zEntPlayerOOBState.cpp | 29 ++ src/SB/Game/zEntPlayerOOBState.h | 32 +++ src/SB/Game/zNPCTypeBossPlankton.cpp | 401 +++++++++++++++++++++++---- src/SB/Game/zNPCTypeBossPlankton.h | 61 ++-- src/SB/Game/zNPCTypeBossSB2.cpp | 38 ++- src/SB/Game/zNPCTypeBossSB2.h | 21 ++ src/SB/Game/zNPCTypeDutchman.cpp | 10 +- 9 files changed, 529 insertions(+), 100 deletions(-) diff --git a/src/SB/Core/x/xDecal.h b/src/SB/Core/x/xDecal.h index 958d5c34c..1d5a4120b 100644 --- a/src/SB/Core/x/xDecal.h +++ b/src/SB/Core/x/xDecal.h @@ -23,7 +23,7 @@ struct xDecalEmitter struct config { U32 flags; - F32 life_time; + F32 life_time; // 0x2ec U32 blend_src; U32 blend_dst; struct diff --git a/src/SB/Core/x/xLaserBolt.h b/src/SB/Core/x/xLaserBolt.h index c4b96f00d..4e8de6048 100644 --- a/src/SB/Core/x/xLaserBolt.h +++ b/src/SB/Core/x/xLaserBolt.h @@ -42,21 +42,6 @@ enum fx_orient_enum FORCE_INT_FX_ORIENT = 0xffffffff }; -struct bolt -{ - xVec3 origin; - xVec3 dir; - xVec3 loc; - xVec3 hit_norm; - F32 dist; - F32 hit_dist; - F32 prev_dist; - F32 prev_check_dist; - xEnt* hit_ent; - F32 emitted; - void* context; -}; - struct xLaserBoltEmitter { struct config @@ -75,6 +60,8 @@ struct xLaserBoltEmitter F32 damage; }; + struct bolt; + struct static_queue { U32 _first; @@ -104,6 +91,21 @@ struct xLaserBoltEmitter F32 irate; }; + struct bolt + { + xVec3 origin; + xVec3 dir; + xVec3 loc; + xVec3 hit_norm; + F32 dist; + F32 hit_dist; + F32 prev_dist; + F32 prev_check_dist; + xEnt* hit_ent; + F32 emitted; + void* context; + }; + config cfg; static_queue bolts; F32 ialpha; @@ -112,6 +114,7 @@ struct xLaserBoltEmitter effect_data* fx[7]; U32 fxsize[7]; + void init(U32 max_bolts, const char*); void set_texture(char* name); void set_texture(U32 aid); void set_texture(RwTexture* tex); @@ -128,6 +131,8 @@ struct xLaserBoltEmitter RxObjSpace3DVertex* get_vert_buffer(S32& dat); void applyDamage(bolt& b); void reset_fx(fx_when_enum when); + + U32 visible() const; }; #endif diff --git a/src/SB/Game/zEntPlayerOOBState.cpp b/src/SB/Game/zEntPlayerOOBState.cpp index a6510aa52..f1d664b13 100644 --- a/src/SB/Game/zEntPlayerOOBState.cpp +++ b/src/SB/Game/zEntPlayerOOBState.cpp @@ -44,6 +44,20 @@ namespace oob_state tagFixed fixed; xMat4x3 shared_target; + static void reset_camera() + { + // xMat4x3 ma, is not correct. This is a major placeholder. + // Simply have not figured out what the data/global is supposed to be + // FIXME: Correct this function + + xMat4x3* ma = xEntGetFrame(&(xEnt)globals.player.ent); + + zCameraEnableInput(); + zCameraEnableTracking(CO_OOB); + xCameraDoCollisions(1, 6); + zCameraTweakGlobal_Init(); + } + static bool assume_player_is_stupid() { shared.tutorial = (ztalkbox*)zSceneFindObject(xStrHash("OUT_OF_BOUNDS_TLKBX")); @@ -74,6 +88,21 @@ namespace oob_state { } + static void set_rect_vert(rwGameCube2DVertex&, F32, F32, F32, iColor_tag, F32) + { + } + + drop_state_type::substate_enum drop_state_type::supdate_fade_in(drop_state_type&, + xScene& scn, F32& unk0) + { + return drop_state_type::update_fade_in(); + } + + drop_state_type::substate_enum drop_state_type::update_fade_in(xScene&, float&) + { + return SS_MOVING_IN; + } + } // namespace } // namespace oob_state diff --git a/src/SB/Game/zEntPlayerOOBState.h b/src/SB/Game/zEntPlayerOOBState.h index 1bbfdaf08..0562ae88e 100644 --- a/src/SB/Game/zEntPlayerOOBState.h +++ b/src/SB/Game/zEntPlayerOOBState.h @@ -4,6 +4,8 @@ #include "xserializer.h" #include "zTalkBox.h" #include "zTaskBox.h" +#include "zCamera.h" +#include "zCameraTweak.h" extern bool oob_player_teleported; @@ -109,6 +111,36 @@ namespace oob_state void stop(); }; + struct drop_state_type : state_type + { + enum substate_enum + { + SS_MOVING_IN, + SS_STOPPING, + SS_STOPPED, + SS_STARTING, + SS_MOVING_OUT, + SS_START_FADE_IN, + SS_FADE_IN, + MAX_SS, + SS_INVALID = 0xffffffff, + }; + + substate_enum move_substate; + substate_enum fade_substate; + xVec3 player_start; + F32 stop_time; + F32 fade_start_time; + F32 fade_time; + substate_enum (*updatess)(drop_state_type&, xScene&, F32&)[7]; + + void start(); + state_enum update(xScene& s, F32& dt); + substate_enum supdate_fade_in(drop_state_type&, xScene&, F32&); + substate_enum update_fade_in(); + substate_enum update_fade_in(xScene&, F32&); + }; + struct _class_9 { int flags; diff --git a/src/SB/Game/zNPCTypeBossPlankton.cpp b/src/SB/Game/zNPCTypeBossPlankton.cpp index e9099f1ad..7b2a0e13d 100644 --- a/src/SB/Game/zNPCTypeBossPlankton.cpp +++ b/src/SB/Game/zNPCTypeBossPlankton.cpp @@ -59,54 +59,115 @@ namespace U32 flags; }; + struct bolt; + + struct effect_data + { + struct effect_callback + { + void (*fp)(bolt&, void*); + void* context; + }; + + fx_type_enum type; + fx_orient_enum orient; + F32 rate; + union + { + xParEmitter* par; + xDecalEmitter* decal; + effect_callback callback; + }; + F32 irate; + }; + + static effect_data beam_launch_effect[2]; // size: 0x30, address: 0x4E0E60 + static effect_data beam_head_effect[1]; // size: 0x18, address: 0x4E0E90 + static effect_data beam_impact_effect[3]; // size: 0x48, address: 0x4E0EB0 + static effect_data beam_death_effect[1]; // size: 0x18, address: 0x5E53F0 + static effect_data beam_kill_effect[1]; + static U32 sound_asset_ids[6][10]; static sound_data_type sound_data[6]; - static const sound_asset sound_assets[29] = - { - {0, "RSB_foot_loop", 0, 3}, - {0, "fan_loop", 0, 3}, - {0, "Rocket_burn_loop", 0, 3}, - {0, "RP_whirr_loop", 0, 3}, - {0, "RP_whirr2_loop", 0, 3}, - {0, "Glove_hover", 0, 3}, - {0, "Glove_pursuit", 0, 3}, - {1, "Prawn_FF_hit", 0, 0}, - {1, "Prawn_hit", 0, 0}, - {1, "Door_metal_shut", 0, 0}, - {1, "Ghostplat_fall", 0, 0}, - {1, "ST-death", 0, 0}, - {1, "RP_Bwrrzt", 0, 0}, - {1, "RP_chunk", 0, 0}, - {1, "b201_rp_exhale", 0, 0}, - {2, "RP_laser_alt", 0, 0}, - {3, "RP_laser_loop", 0, 1}, - {3, "ElecArc_alt_b", 0, 1}, - {3, "Laser_lrg_fire_loop", 0, 1}, - {3, "Laser_sm_fire_loop", 0, 1}, - {4, "RB_stalact_brk", 0, 0}, - {4, "Volcano_blast", 0, 0}, - {4, "RP_laser_thunk", 0, 0}, - {4, "RP_pfft", 0, 0}, - {4, "RP_thwash", 0, 0}, - {5, "RP_charge_whirr", 0, 0}, - {5, "B101_SC_jump", 0, 0}, - {5, "KJ_Charge", 0, 0}, - {5, "Laser_med_pwrup1", 0, 0} + + static const sound_asset sound_assets[29] = { + { 0, "RSB_foot_loop", 0, 3 }, { 0, "fan_loop", 0, 3 }, + { 0, "Rocket_burn_loop", 0, 3 }, { 0, "RP_whirr_loop", 0, 3 }, + { 0, "RP_whirr2_loop", 0, 3 }, { 0, "Glove_hover", 0, 3 }, + { 0, "Glove_pursuit", 0, 3 }, { 1, "Prawn_FF_hit", 0, 0 }, + { 1, "Prawn_hit", 0, 0 }, { 1, "Door_metal_shut", 0, 0 }, + { 1, "Ghostplat_fall", 0, 0 }, { 1, "ST-death", 0, 0 }, + { 1, "RP_Bwrrzt", 0, 0 }, { 1, "RP_chunk", 0, 0 }, + { 1, "b201_rp_exhale", 0, 0 }, { 2, "RP_laser_alt", 0, 0 }, + { 3, "RP_laser_loop", 0, 1 }, { 3, "ElecArc_alt_b", 0, 1 }, + { 3, "Laser_lrg_fire_loop", 0, 1 }, { 3, "Laser_sm_fire_loop", 0, 1 }, + { 4, "RB_stalact_brk", 0, 0 }, { 4, "Volcano_blast", 0, 0 }, + { 4, "RP_laser_thunk", 0, 0 }, { 4, "RP_pfft", 0, 0 }, + { 4, "RP_thwash", 0, 0 }, { 5, "RP_charge_whirr", 0, 0 }, + { 5, "B101_SC_jump", 0, 0 }, { 5, "KJ_Charge", 0, 0 }, + { 5, "Laser_med_pwrup1", 0, 0 } }; + const size_t beam_ring_curve = 2; + + xVec3* get_player_loc() + { + return (xVec3*)&globals.player.ent.model->Mat->pos; + } S32 init_sound() { return 0; } - F32 get_player_loc() + void reset_sound() + { + for (S32 i = 0; i < 6; ++i) + { + sound_data[i].handle = 0; + } + } + + void* play_sound(int, const xVec3*, float) + { + return NULL; + } + + void* kill_sound(S32, U32) + { + return 0; // to-do + } + + void* kill_sound(S32) { return 0; } - void play_sound(int, const xVec3*, float) + void play_beam_fly_sound(xLaserBoltEmitter::bolt& bolt, void* unk) + { + if (bolt.context == NULL) + { + bolt.context = play_sound(SOUND_BOLT_FLY, &bolt.loc, 1.0f); + } + } + + void kill_beam_fly_sound(xLaserBoltEmitter::bolt& bolt, void* unk) + { + if (bolt.context != NULL) + { + kill_sound(3, (U32)bolt.context); + bolt.context = NULL; + } + } + + void play_beam_fire_sound(xLaserBoltEmitter::bolt& bolt, void* unk) { + play_sound(SOUND_BOLT_FIRE, &bolt.origin, 1.0f); + } + + void play_beam_hit_sound(xLaserBoltEmitter::bolt& bolt, void* unk) + { + play_sound(SOUND_BOLT_HIT, &bolt.loc, 1.0f); } struct config @@ -233,9 +294,17 @@ namespace tweak_callback cb_sound; tweak_callback cb_sound_asset; + void load(xModelAssetParam*, U32); void register_tweaks(bool init, xModelAssetParam* ap, U32 apsize, const char*); }; + static tweak_group tweak; + + void tweak_group::load(xModelAssetParam* ap, U32 apsize) + { + register_tweaks(true, ap, apsize, NULL); + } + void tweak_group::register_tweaks(bool init, xModelAssetParam* ap, U32 apsize, const char*) { xVec3 V0; @@ -829,17 +898,20 @@ namespace if (init) { sound[SOUND_BOLT_FIRE].asset = sound_asset_ids[2][0]; - sound_data[SOUND_BOLT_FIRE].id = xStrHash(sound_assets[sound[SOUND_BOLT_FIRE].asset].name); + sound_data[SOUND_BOLT_FIRE].id = + xStrHash(sound_assets[sound[SOUND_BOLT_FIRE].asset].name); } if (init) { sound[SOUND_BOLT_FLY].asset = sound_asset_ids[3][3]; - sound_data[SOUND_BOLT_FLY].id = xStrHash(sound_assets[sound[SOUND_BOLT_FLY].asset].name); + sound_data[SOUND_BOLT_FLY].id = + xStrHash(sound_assets[sound[SOUND_BOLT_FLY].asset].name); } if (init) { sound[SOUND_BOLT_HIT].asset = sound_asset_ids[4][3]; - sound_data[SOUND_BOLT_HIT].id = xStrHash(sound_assets[sound[SOUND_BOLT_HIT].asset].name); + sound_data[SOUND_BOLT_HIT].id = + xStrHash(sound_assets[sound[SOUND_BOLT_HIT].asset].name); } if (init) { @@ -848,6 +920,18 @@ namespace } } + static void update_move_accel(xVec3& loc, zNPCBPlankton::move_info& move, F32 dt) + { + // Ghidra output, will come back to this later + + // xAccelMove((double)*(float*)(param_3 + 0x18), param_1_00, (double)*(float*)(param_3 + 0x24), + // (float*)this, (float*)(param_3 + 0xc)); + // xAccelMove((double)*(float*)(param_3 + 0x1c), param_1_00, (double)*(float*)(param_3 + 0x28), + // (float*)(this + 4), (float*)(param_3 + 0x10)); + // xAccelMove((double)*(float*)(param_3 + 0x20), param_1_00, (double)*(float*)(param_3 + 0x2c), + // (float*)(this + 8), (float*)(param_3 + 0x14)); + } + } // namespace xAnimTable* ZNPC_AnimTable_BossPlankton() @@ -988,6 +1072,33 @@ void zNPCBPlankton::Init(xEntAsset* asset) //66% zNPCBPlankton::aim_gun(play, &gun_tilt, &move.dest, 0); } +void zNPCBPlankton::Setup() +{ + U32 tmpVar; + + zNPCBoss::Setup(); + zNPCBPlankton::setup_beam(); + tmpVar = xStrHash("NPC_NEWSCASTER"); + newsfish = (zNPCNewsFish*)zSceneFindObject(tmpVar); +} + +void zNPCBPlankton::PostSetup() +{ + xUpdateCull_SetCB(xglobals->updateMgr, NULL, xUpdateCull_AlwaysTrueCB, NULL); +} + +void zNPCBPlankton::Reset() +{ + if (newsfish != 0) + { + } + + zNPCCommon::Reset(); + zNPCBPlankton::reset_beam(); + memset((void*)flag.updated, 0, 0x10); + zNPCBPlankton::face_player(); +} + void zNPCBPlankton::Destroy() { zNPCCommon::Destroy(); @@ -1050,12 +1161,37 @@ void zNPCBPlankton::Process(xScene* xscn, float dt) //Process__10zNPCCommonFP6xScenef(param_1,param_9,param_10); } +S32 zNPCBPlankton::SysEvent(xBase* from, xBase* to, U32 toEvent, const F32* toParam, + xBase* toParamWidget, S32* handled) +{ + *handled = 0; + return zNPCCommon::SysEvent(from, to, toEvent, toParam, toParamWidget, handled); + + // ((zNPCCommon*) 0x1b8??? +} + void zNPCBPlankton::Render() { xNPCBasic::Render(); zNPCBPlankton::render_debug(); } +void zNPCBPlankton::RenderExtraPostParticles() +{ + if ((beam.visible() & 0xff) != 0) + { + RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)5); + RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)2); + beam.render(); + } +} + +void zNPCBPlankton::ParseINI() +{ + zNPCCommon::ParseINI(); + tweak.load(parmdata, pdatsize); +} + void zNPCBPlankton::SelfSetup() { xBehaveMgr* bmgr = xBehaveMgr_GetSelf(); @@ -1168,15 +1304,138 @@ S32 zNPCBPlankton::next_goal() } void zNPCBPlankton::render_debug() +{ + // weak +} + +void zNPCBPlankton::reset_territories() +{ +} + +void zNPCBPlankton::update_animation(F32) { } -void zNPCBPlankton::update_animation(float) +void zNPCBPlankton::update_follow(F32 dt) { + if (flag.follow != 2) + { + update_follow_player(dt); + } + else if ((flag.follow < 2) && (1 > flag.follow)) + { + update_follow_camera(dt); + } +} + +void zNPCBPlankton::check_player_damage() +{ + // TODO +} + +void zNPCBPlankton::init_beam() +{ + beam.init((U32)&beam, "Plankton\'s Beam"); + beam.set_texture("plankton_laser_bolt"); + + beam.refresh_config(); + // + beam_ring.init(0, "Plankton\'s Beam Rings"); + beam_ring.set_curve((xDecalEmitter::curve_node*)&beam_ring.curve, beam_ring_curve); + beam_ring.set_texture("bubble"); + beam_ring.set_default_config(); + beam_ring.cfg.flags = 0; + beam_ring.cfg.life_time = 0.0f; + beam_ring.cfg.blend_src = 5; + beam_ring.cfg.blend_dst = 2; + beam_ring.refresh_config(); + + // + beam_glow.init(0, "Plankton\'s Beam Glow"); + beam_glow.set_curve((xDecalEmitter::curve_node*)&beam_glow.curve, 0); + beam_glow.set_texture("fx_firework"); + beam_glow.set_default_config(); + beam_glow.cfg.flags = 0; + beam_glow.cfg.life_time = 0.0f; + beam_glow.cfg.blend_src = 5; + beam_glow.cfg.blend_dst = 2; + beam_glow.refresh_config(); +} + +void zNPCBPlankton::setup_beam() +{ +} + +void zNPCBPlankton::reset_beam() +{ + beam.reset(); } void zNPCBPlankton::vanish() { + flags = flags & 0xfe; + flags = flags | 0x40; + pflags = 0; + moreFlags = 0; + chkby = 0; + penby = 0; + flags2.flg_colCheck = 0; + flags2.flg_penCheck = 0; + kill_sound(NULL); +} + +void zNPCBPlankton::reappear() +{ + flags = flags | 1; + flags = flags & 0xbf; + pflags = 0; + moreFlags = 16; + chkby = 16; + penby = 16; + flags2.flg_colCheck = 0; + flags2.flg_penCheck = 0; + play_sound(0, (xVec3*)&bound.pad[3], 1.0f); +} + +void zNPCBPlankton::next_territory() +{ + if ((have_cronies() & 0xff) != 0) + { + active_territory = active_territory + 1; + if (active_territory >= territory_size) + { + active_territory = territory_size + -1; + } + } +} + +S32 zNPCBPlankton::have_cronies() const +{ + // FIXME: dunno how to fix this yet + return (active_territory) & (active_territory * 0x3c + 0x4e4) >> 0x1f; +} + +void zNPCBPlankton::sickum() +{ +} + +void zNPCBPlankton::here_boy() +{ + flag.hunt = 0; +} + +void zNPCBPlankton::follow_player() +{ + flag.follow = FOLLOW_PLAYER; + follow.delay = follow.max_delay = 0.0f; + flag.move = MOVE_ORBIT; +} + +void zNPCBPlankton::follow_camera() +{ + flag.follow = FOLLOW_CAMERA; + follow.delay = follow.max_delay = 0.0f; + flag.move = MOVE_ORBIT; } S32 zNPCBPlankton::IsAlive() @@ -1204,16 +1463,64 @@ xFactoryInst* zNPCGoalBPlanktonIdle::create(S32 who, RyzMemGrow* grow, void* inf return new (who, grow) zNPCGoalBPlanktonIdle(who, (zNPCBPlankton&)*info); } +S32 zNPCGoalBPlanktonIdle::Enter(F32 dt, void* ctxt) +{ + F32 tmpFloat; + F32 local_24[3]; + + owner.reappear(); + owner.flag.attacking = false; + owner.refresh_orbit(); + owner.reset_speed(); + owner.flag.follow = owner.FOLLOW_NONE; + get_yaw(tmpFloat, dt); + apply_yaw(tmpFloat); + return zNPCGoalCommon::Enter(dt, ctxt); +} + +S32 zNPCGoalBPlanktonIdle::Exit(F32 dt, void* ctxt) +{ + owner.refresh_orbit(); + return xGoal::Exit(dt, ctxt); +} + xFactoryInst* zNPCGoalBPlanktonAttack::create(S32 who, RyzMemGrow* grow, void* info) { return new (who, grow) zNPCGoalBPlanktonAttack(who, (zNPCBPlankton&)*info); } +S32 zNPCGoalBPlanktonAttack::Enter(F32 dt, void* ctxt) +{ + owner.reappear(); + owner.flag.attacking = true; + owner.refresh_orbit(); + owner.follow_player(); + owner.delay = 0.0f; + owner.face_player(); + owner.reset_speed(); + return zNPCGoalCommon::Enter(dt, ctxt); +} + +S32 zNPCGoalBPlanktonAttack::Exit(F32 dt, void* ctxt) +{ + return xGoal::Exit(dt, ctxt); +} + xFactoryInst* zNPCGoalBPlanktonAmbush::create(S32 who, RyzMemGrow* grow, void* info) { return new (who, grow) zNPCGoalBPlanktonAmbush(who, (zNPCBPlankton&)*info); } +S32 zNPCGoalBPlanktonAmbush::Enter(F32 dt, void* ctxt) +{ + return zNPCGoalCommon::Enter(dt, ctxt); +} + +S32 zNPCGoalBPlanktonAmbush::Exit(F32 dt, void* ctxt) +{ + return xGoal::Exit(dt, ctxt); +} + xFactoryInst* zNPCGoalBPlanktonFlank::create(S32 who, RyzMemGrow* grow, void* info) { return new (who, grow) zNPCGoalBPlanktonFlank(who, (zNPCBPlankton&)*info); @@ -1229,7 +1536,7 @@ xFactoryInst* zNPCGoalBPlanktonHunt::create(S32 who, RyzMemGrow* grow, void* inf return new (who, grow) zNPCGoalBPlanktonHunt(who, (zNPCBPlankton&)*info); } -S32 zNPCGoalBPlanktonHunt::Enter(float dt, void* updCtxt) +S32 zNPCGoalBPlanktonHunt::Enter(F32 dt, void* updCtxt) { owner.reappear(); get_player_loc(); @@ -1241,7 +1548,7 @@ S32 zNPCGoalBPlanktonHunt::Enter(float dt, void* updCtxt) return zNPCGoalCommon::Enter(dt, updCtxt); } -S32 zNPCGoalBPlanktonHunt::Exit(float dt, void* updCtxt) +S32 zNPCGoalBPlanktonHunt::Exit(F32 dt, void* updCtxt) { owner.refresh_orbit(); return xGoal::Exit(dt, updCtxt); @@ -1312,24 +1619,22 @@ xFactoryInst* zNPCGoalBPlanktonBeam::create(S32 who, RyzMemGrow* grow, void* inf S32 zNPCGoalBPlanktonBeam::Enter(float dt, void* updCtxt) { - xParEmitter parE; - xParEmitter& pEmit = parE; // this is one of the codes of all time owner.reappear(); + substate = SS_WARM_UP; owner.delay = 0.0f; - emitted = 0.0f; + emitted = 0; + owner.flag.aim_gun = true; owner.flag.follow = owner.FOLLOW_NONE; - owner.enable_emitter(pEmit); - void play_sound(S32, const xVec3*, F32); // dunno how to get this to call properly + owner.enable_emitter((xParEmitter&)owner.beam_charge); + play_sound(5, (xVec3*)&owner.bound.pad[3], 1.0f); // dunno how to get this to call properly return zNPCGoalCommon::Enter(dt, updCtxt); } S32 zNPCGoalBPlanktonBeam::Exit(float dt, void* updCtxt) { - xParEmitter parE; - xParEmitter& pEmit = parE; // this is one of the codes of all time owner.flag.aim_gun = false; - owner.flag.follow = owner.FOLLOW_NONE; - owner.disable_emitter(pEmit); + owner.flag.follow = owner.FOLLOW_PLAYER; + owner.disable_emitter((xParEmitter&)owner.beam_charge); return xGoal::Exit(dt, updCtxt); } diff --git a/src/SB/Game/zNPCTypeBossPlankton.h b/src/SB/Game/zNPCTypeBossPlankton.h index 075125dad..7836d4a53 100644 --- a/src/SB/Game/zNPCTypeBossPlankton.h +++ b/src/SB/Game/zNPCTypeBossPlankton.h @@ -2,6 +2,7 @@ #define ZNPCTYPEBOSSPLANKTON_H #include "zNPCTypeBoss.h" +#include "zNPCTypeVillager.h" #include "zNPCGoalCommon.h" #include "zEntDestructObj.h" @@ -10,8 +11,7 @@ #include "xTimer.h" #include "zNPCGoals.h" #include "xParEmitter.h" - -struct zNPCNewsFish; +#include "xLaserBolt.h" namespace auto_tweak { @@ -77,8 +77,8 @@ struct zNPCBPlankton : zNPCBoss F32 delay; //0x2c8 xQuat gun_tilt; F32 ambush_delay; - F32 beam_duration; - F32 stun_duration; + F32 beam_duration; // 0x2e0 + F32 stun_duration; // 0x2e4 xDecalEmitter beam_ring; xDecalEmitter beam_glow; xLaserBoltEmitter beam; @@ -115,28 +115,43 @@ struct zNPCBPlankton : zNPCBoss zNPCBPlankton(S32 myType); void Init(xEntAsset*); + void Setup(); + void PostSetup(); + void Reset(); void Destroy(); void Process(xScene*, float); + S32 SysEvent(xBase*, xBase*, unsigned int, const float*, xBase*, int*); void Render(); + void RenderExtraPostParticles(); + void ParseINI(); void SelfSetup(); U32 AnimPick(int, en_NPC_GOAL_SPOT, xGoal*); S32 next_goal(); void render_debug(); - void update_turn(float); - void update_move(float); + void update_turn(F32); + void update_move(F32); void check_player_damage(); - void update_animation(float); - void update_follow(float); - void update_aim_gun(float); - void update_dialog(float); + void reset_territories(); + void update_animation(F32); + void update_follow(F32); + void update_follow_player(F32); + void update_follow_camera(F32); + void update_aim_gun(F32); + void update_dialog(F32); void init_beam(); + void setup_beam(); + void reset_beam(); void vanish(); void reappear(); U32 crony_attacking() const; + void next_territory(); + S32 have_cronies() const; S32 player_left_territory(); void say(int, int, bool); + void sickum(); void aim_gun(xAnimPlay*, xQuat*, xVec3*, int); void here_boy(); + void follow_player(); void follow_camera(); void reset_speed(); void refresh_orbit(); @@ -146,9 +161,10 @@ struct zNPCBPlankton : zNPCBoss U8 ColChkFlags() const; U8 ColChkByFlags() const; - // Not yet organized + // Not yet organized / WEAK void enable_emitter(xParEmitter&) const; void disable_emitter(xParEmitter&) const; + void face_player(); }; struct zNPCGoalBPlanktonIdle : zNPCGoalCommon @@ -160,6 +176,11 @@ struct zNPCGoalBPlanktonIdle : zNPCGoalCommon } static xFactoryInst* create(S32 who, RyzMemGrow* grow, void* info); + S32 Enter(F32, void*); + S32 Exit(F32, void*); + + S32 get_yaw(F32&, F32&) const; + S32 apply_yaw(F32); }; struct zNPCGoalBPlanktonAttack : zNPCGoalCommon @@ -171,6 +192,8 @@ struct zNPCGoalBPlanktonAttack : zNPCGoalCommon } static xFactoryInst* create(S32 who, RyzMemGrow* grow, void* info); + S32 Enter(F32, void*); + S32 Exit(F32, void*); }; struct zNPCGoalBPlanktonAmbush : zNPCGoalCommon @@ -182,6 +205,8 @@ struct zNPCGoalBPlanktonAmbush : zNPCGoalCommon } static xFactoryInst* create(S32 who, RyzMemGrow* grow, void* info); + S32 Enter(F32, void*); + S32 Exit(F32, void*); }; struct zNPCGoalBPlanktonFlank : zNPCGoalCommon @@ -219,8 +244,8 @@ struct zNPCGoalBPlanktonHunt : zNPCGoalCommon static xFactoryInst* create(S32 who, RyzMemGrow* grow, void* info); - S32 Enter(float, void*); - S32 Exit(float, void*); + S32 Enter(F32, void*); + S32 Exit(F32, void*); }; struct zNPCGoalBPlanktonTaunt : zNPCGoalCommon @@ -232,7 +257,7 @@ struct zNPCGoalBPlanktonTaunt : zNPCGoalCommon } static xFactoryInst* create(S32 who, RyzMemGrow* grow, void* info); - S32 Process(en_trantype*, float, void*, xScene*); + S32 Process(en_trantype*, F32, void*, xScene*); }; struct zNPCGoalBPlanktonMove : zNPCGoalCommon @@ -244,7 +269,7 @@ struct zNPCGoalBPlanktonMove : zNPCGoalCommon } static xFactoryInst* create(S32 who, RyzMemGrow* grow, void* info); - S32 Process(en_trantype*, float, void*, xScene*); + S32 Process(en_trantype*, F32, void*, xScene*); }; struct zNPCGoalBPlanktonStun : zNPCGoalCommon @@ -256,9 +281,9 @@ struct zNPCGoalBPlanktonStun : zNPCGoalCommon } static xFactoryInst* create(S32 who, RyzMemGrow* grow, void* info); - S32 Enter(float, void*); - S32 Exit(float, void*); - S32 Process(en_trantype*, float, void*, xScene*); + S32 Enter(F32, void*); + S32 Exit(F32, void*); + S32 Process(en_trantype*, F32, void*, xScene*); }; struct zNPCGoalBPlanktonFall : zNPCGoalCommon diff --git a/src/SB/Game/zNPCTypeBossSB2.cpp b/src/SB/Game/zNPCTypeBossSB2.cpp index c8f61e473..5df7f7e10 100644 --- a/src/SB/Game/zNPCTypeBossSB2.cpp +++ b/src/SB/Game/zNPCTypeBossSB2.cpp @@ -83,20 +83,11 @@ namespace static U32 sound_asset_ids[10][4]; static sound_data_type sound_data[10]; - static const sound_asset sound_assets[12] = - { - {0, "RSB_laugh", 0, 0}, - {1, "RSB_kah", 0, 0}, - {2, "RSB_chop_windup", 0, 0}, - {3, "RSB_chop_swing", 0, 0}, - {4, "RSB_swipe", 0, 0}, - {5, "RSB_foot_loop", 0, 1}, - {6, "RSB_armhit1", 0, 0}, - {6, "RSB_armhit2", 0, 0}, - {7, "RSB_armhit1", 0, 0}, - {7, "RSB_armhit2", 0, 0}, - {8, "RSB_armsmash", 0, 0}, - {9, "RSB_foor_impact", 0, 0}, + static const sound_asset sound_assets[12] = { + { 0, "RSB_laugh", 0, 0 }, { 1, "RSB_kah", 0, 0 }, { 2, "RSB_chop_windup", 0, 0 }, + { 3, "RSB_chop_swing", 0, 0 }, { 4, "RSB_swipe", 0, 0 }, { 5, "RSB_foot_loop", 0, 1 }, + { 6, "RSB_armhit1", 0, 0 }, { 6, "RSB_armhit2", 0, 0 }, { 7, "RSB_armhit1", 0, 0 }, + { 7, "RSB_armhit2", 0, 0 }, { 8, "RSB_armsmash", 0, 0 }, { 9, "RSB_foor_impact", 0, 0 }, }; S32 set_alpha_blend(xModelInstance*) @@ -118,6 +109,14 @@ namespace return 0; // to-do } + void reset_sound() + { + for (S32 i = 0; i < 10; ++i) + { + sound_data[i].handle = 0; + } + } + S32 play_sound(int, const xVec3*, float) { return 0; // to-do @@ -223,6 +222,11 @@ namespace void register_tweaks(bool init, xModelAssetParam* ap, U32 apsize, const char*); }; + void tweak_group::load(xModelAssetParam* params, U32 size) + { + tweak_group::register_tweaks(true, params, size, NULL); + } + void tweak_group::register_tweaks(bool init, xModelAssetParam* ap, U32 apsize, const char*) { if (init) @@ -975,6 +979,10 @@ namespace } } + void response_curve::end_t() const + { + } + } // namespace xAnimTable* ZNPC_AnimTable_BossSB2() @@ -1285,7 +1293,7 @@ S32 zNPCGoalBossSB2Idle::Exit(float dt, void* updCtxt) S32 zNPCGoalBossSB2Taunt::Enter(float dt, void* updCtxt) { - ::play_sound(0, &owner.sound_loc.mouth , 1.0f); + play_sound(0, &owner.sound_loc.mouth , 1.0f); owner.flag.face_player = 1; return zNPCGoalCommon::Enter(dt, updCtxt); } diff --git a/src/SB/Game/zNPCTypeBossSB2.h b/src/SB/Game/zNPCTypeBossSB2.h index c0b80c4e4..bff1a91a2 100644 --- a/src/SB/Game/zNPCTypeBossSB2.h +++ b/src/SB/Game/zNPCTypeBossSB2.h @@ -14,6 +14,27 @@ namespace auto_tweak void load_param(T1&, T2, T2, T2, xModelAssetParam*, U32, const char*); }; +struct inode; + +struct response_curve +{ + U32 values; // offset 0x0, + inode* curve; // offset 0x4, + U32 nodes; // offset 0x8, + U32 active_node; // offset 0xC, + + void end_t() const; +}; +struct node +{ + F32 t; +}; + +struct inode : node +{ + F32 value[1]; +}; + struct zNPCB_SB2 : zNPCBoss { enum move_enum diff --git a/src/SB/Game/zNPCTypeDutchman.cpp b/src/SB/Game/zNPCTypeDutchman.cpp index 34b003386..321bb0747 100644 --- a/src/SB/Game/zNPCTypeDutchman.cpp +++ b/src/SB/Game/zNPCTypeDutchman.cpp @@ -5,7 +5,6 @@ #include - #define f1605 0.0f #define f1606 1.0f #define f1689 0.2f @@ -36,6 +35,7 @@ static U32 dutchman_count; namespace { + void kill_sound(S32 a, U32 b) { } @@ -161,10 +161,15 @@ namespace tweak_callback cb_blob_pitch; tweak_callback cb_sound; - void register_tweaks(bool init, xModelAssetParam* ap, U32 apsize, const char*); }; + static tweak_group tweak; + + static void set_volume(S32 which, U32, F32 new_vol) + { + } + void tweak_group::register_tweaks(bool init, xModelAssetParam* ap, U32 apsize, const char*) { if (init) @@ -1345,7 +1350,6 @@ xFactoryInst* zNPCGoalDutchmanPostFlame::create(S32 who, RyzMemGrow* grow, void* return new (who, grow) zNPCGoalDutchmanPostFlame(who, (zNPCDutchman&)*info); } - S32 zNPCGoalDutchmanPostFlame::Exit(F32 dt, void* updCtxt) { owner.flag.hurting = 0; From 193a788d5f9a4c538e89cc1d685b3d7baf8d007c Mon Sep 17 00:00:00 2001 From: Colin Miller Date: Sun, 24 Aug 2025 15:57:58 -0400 Subject: [PATCH 04/13] zTalkbox, xScrFx & misc (#590) * ported zNPCSupport code, zNPCTypeCommon * build fix * BossSB2 & BossPlankton * zTalkbox work and xScrFx * Floating point error handler func --- src/SB/Core/gc/iMix.c | 39 ++--- src/SB/Core/gc/iSystem.cpp | 64 ++++++++ src/SB/Core/gc/iSystem.h | 1 + src/SB/Core/x/containers.h | 1 + src/SB/Core/x/xScrFx.cpp | 153 +++++++++++++++++++ src/SB/Core/x/xScrFx.h | 63 ++++++-- src/SB/Game/zMenu.h | 1 + src/SB/Game/zTalkBox.cpp | 301 +++++++++++++++++++++++++------------ src/SB/Game/zTalkBox.h | 171 +++++++++++++++++++++ 9 files changed, 663 insertions(+), 131 deletions(-) diff --git a/src/SB/Core/gc/iMix.c b/src/SB/Core/gc/iMix.c index c4e123ac0..a8e02bd91 100644 --- a/src/SB/Core/gc/iMix.c +++ b/src/SB/Core/gc/iMix.c @@ -230,8 +230,8 @@ void MIXInit() __MIXSoundMode = OSGetSoundMode(); } -void MIXInitChannel(S32 param_1, U32 param_2, S32 param_3, S32 param_4, S32 param_5, - S32 param_6, S32 param_7, S32 param_8) +void MIXInitChannel(S32 param_1, U32 param_2, S32 param_3, S32 param_4, S32 param_5, S32 param_6, + S32 param_7, S32 param_8) { struct MIXChannel* chan = &__MIXChannel[*(S32*)((S32)param_1 + 0x18)]; @@ -271,8 +271,7 @@ void MIXInitChannel(S32 param_1, U32 param_2, S32 param_3, S32 param_4, S32 para { *(U16*)(&chan->data[0x12]) = __MIXGetVolume(chan->data[3] + chan->data[10]); *(U16*)(&chan->data[0x13]) = __MIXGetVolume(chan->data[3] + chan->data[10]); - *(U16*)(&chan->data[0x14]) = - __MIXGetVolume(chan->data[3] + chan->data[11] - 0x3c); + *(U16*)(&chan->data[0x14]) = __MIXGetVolume(chan->data[3] + chan->data[11] - 0x3c); } else { @@ -288,8 +287,7 @@ void MIXInitChannel(S32 param_1, U32 param_2, S32 param_3, S32 param_4, S32 para { *(U16*)(&chan->data[0x15]) = __MIXGetVolume(chan->data[4] + chan->data[10]); *(U16*)(&chan->data[0x16]) = __MIXGetVolume(chan->data[4] + chan->data[10]); - *(U16*)(&chan->data[0x17]) = - __MIXGetVolume(chan->data[4] + chan->data[11] - 0x3c); + *(U16*)(&chan->data[0x17]) = __MIXGetVolume(chan->data[4] + chan->data[11] - 0x3c); } else { @@ -305,10 +303,8 @@ void MIXInitChannel(S32 param_1, U32 param_2, S32 param_3, S32 param_4, S32 para case 1: case 2: - *(U16*)(&chan->data[0xf]) = - __MIXGetVolume(chan->data[7] + chan->data[8] + chan->data[10]); - *(U16*)(&chan->data[0x10]) = - __MIXGetVolume(chan->data[7] + chan->data[9] + chan->data[10]); + *(U16*)(&chan->data[0xf]) = __MIXGetVolume(chan->data[7] + chan->data[8] + chan->data[10]); + *(U16*)(&chan->data[0x10]) = __MIXGetVolume(chan->data[7] + chan->data[9] + chan->data[10]); *(U16*)(&chan->data[0x11]) = __MIXGetVolume(chan->data[7] + chan->data[11]); if ((chan->data[1] & 1) != 0) @@ -317,8 +313,7 @@ void MIXInitChannel(S32 param_1, U32 param_2, S32 param_3, S32 param_4, S32 para __MIXGetVolume(chan->data[3] + chan->data[8] + chan->data[10]); *(U16*)(&chan->data[0x13]) = __MIXGetVolume(chan->data[3] + chan->data[9] + chan->data[10]); - *(U16*)(&chan->data[0x14]) = - __MIXGetVolume(chan->data[3] + chan->data[11] + -0x3c); + *(U16*)(&chan->data[0x14]) = __MIXGetVolume(chan->data[3] + chan->data[11] + -0x3c); } else { @@ -335,8 +330,7 @@ void MIXInitChannel(S32 param_1, U32 param_2, S32 param_3, S32 param_4, S32 para __MIXGetVolume(chan->data[4] + chan->data[8] + chan->data[10]); *(U16*)(&chan->data[0x16]) = __MIXGetVolume(chan->data[4] + chan->data[9] + chan->data[10]); - *(U16*)(&chan->data[0x17]) = - __MIXGetVolume(chan->data[4] + chan->data[11] + -0x3c); + *(U16*)(&chan->data[0x17]) = __MIXGetVolume(chan->data[4] + chan->data[11] + -0x3c); } else { @@ -350,14 +344,10 @@ void MIXInitChannel(S32 param_1, U32 param_2, S32 param_3, S32 param_4, S32 para break; case 3: - *(U16*)(&chan->data[15]) = - __MIXGetVolume(chan->data[7] + chan->data[8] + chan->data[10]); - *(U16*)(&chan->data[16]) = - __MIXGetVolume(chan->data[7] + chan->data[9] + chan->data[10]); - *(U16*)(&chan->data[21]) = - __MIXGetVolume(chan->data[7] + chan->data[12] + chan->data[11]); - *(U16*)(&chan->data[22]) = - __MIXGetVolume(chan->data[7] + chan->data[13] + chan->data[11]); + *(U16*)(&chan->data[15]) = __MIXGetVolume(chan->data[7] + chan->data[8] + chan->data[10]); + *(U16*)(&chan->data[16]) = __MIXGetVolume(chan->data[7] + chan->data[9] + chan->data[10]); + *(U16*)(&chan->data[21]) = __MIXGetVolume(chan->data[7] + chan->data[12] + chan->data[11]); + *(U16*)(&chan->data[22]) = __MIXGetVolume(chan->data[7] + chan->data[13] + chan->data[11]); if ((chan->data[1] & 1) != 0) { @@ -388,8 +378,7 @@ void MIXInitChannel(S32 param_1, U32 param_2, S32 param_3, S32 param_4, S32 para int enabled = OSDisableInterrupts(); - *(U16*)((S32)param_1 + 0x19c) = - *(U16*)(&chan->data[0xe]); + *(U16*)((S32)param_1 + 0x19c) = *(U16*)(&chan->data[0xe]); *(U16*)((S32)param_1 + 0x19e) = 0; if ((*(U16*)((S32)param_1 + 0x14a) = *(U16*)(&chan->data[0xf]))) { @@ -496,4 +485,4 @@ S32 MIXGetFader(S32* param_1) { S32* handle = &__MIXChannel[*(param_1 + 6)].data[0]; return handle[7]; -} \ No newline at end of file +} diff --git a/src/SB/Core/gc/iSystem.cpp b/src/SB/Core/gc/iSystem.cpp index 967189b30..6f33000d3 100644 --- a/src/SB/Core/gc/iSystem.cpp +++ b/src/SB/Core/gc/iSystem.cpp @@ -62,6 +62,70 @@ U16 my_dsc(U16 dsc) return dsc; } +void FloatingPointErrorHandler(U16 last, OSContext* ctxt, U64 unk1, U64 unk2) +{ + U32 uVar2; + uVar2 = (ctxt->fpscr) & 0xf8 << 0x16 | 0x1f80700; + if ((uVar2 & 0x20000000) != 0) + { + OSReport("FPE: Invalid operation: "); + + if ((uVar2 & 0x1000000) != 0) + { + OSReport("SNaN\n"); + } + if ((uVar2 & 0x800000) != 0) + { + OSReport("Infinity - Infinity\n"); + } + if ((uVar2 & 0x400000) != 0) + { + OSReport("Infinity / Infinity\n"); + } + if ((uVar2 & 0x200000) != 0) + { + OSReport("0 / 0\n"); + } + if ((uVar2 & 0x100000) != 0) + { + OSReport("Infinity * 0\n"); + } + if ((uVar2 & 0x80000) != 0) + { + OSReport("Invalid compare\n"); + } + if ((uVar2 & 0x400) != 0) + { + OSReport("Software request\n"); + } + if ((uVar2 & 0x200) != 0) + { + OSReport("Invalid square root\n"); + } + if ((uVar2 & 0x100) != 0) + { + OSReport("Invalid integer convert\n"); + } + } + if ((uVar2 & 0x10000000) != 0) + { + OSReport("FPE: Overflow\n"); + } + if ((uVar2 & 0x8000000) != 0) + { + OSReport("FPE: Underflow\n"); + } + if ((uVar2 & 0x4000000) != 0) + { + OSReport("FPE: Zero division\n"); + } + if ((uVar2 & 0x2000000) != 0) + { + OSReport("FPE: Inexact result\n"); + } + ctxt->srr0 = ctxt->srr0 + 4; +} + void MemoryProtectionErrorHandler(U16 last, OSContext* ctx, U64 unk1, U64 unk2) { last_error = last; diff --git a/src/SB/Core/gc/iSystem.h b/src/SB/Core/gc/iSystem.h index 83191f2a5..f0c620a86 100644 --- a/src/SB/Core/gc/iSystem.h +++ b/src/SB/Core/gc/iSystem.h @@ -21,6 +21,7 @@ U16 my_dsc(U16 dsc); void iSystemInit(U32 options); void iSystemExit(); void MemoryProtectionErrorHandler(U16 last, OSContext* ctx, U64 unk1, U64 unk2); +void FloatingPointErrorHandler(U16 last, OSContext* ctxt, U64 unk1, U64 unk2); void TRCInit(); void null_func(); diff --git a/src/SB/Core/x/containers.h b/src/SB/Core/x/containers.h index ff9688cb8..befdffb6f 100644 --- a/src/SB/Core/x/containers.h +++ b/src/SB/Core/x/containers.h @@ -51,6 +51,7 @@ template struct fixed_queue void reset(); void push_front(const T& element); + void push_back(); bool full() const; void pop_back(); bool empty() const; diff --git a/src/SB/Core/x/xScrFx.cpp b/src/SB/Core/x/xScrFx.cpp index deb113982..2d14f9efb 100644 --- a/src/SB/Core/x/xScrFx.cpp +++ b/src/SB/Core/x/xScrFx.cpp @@ -2,6 +2,145 @@ #include +U8 g_debugRenderSafeArea; + +static F32 mLetterboxO; +static F32 mLetterboxTO; +static F32 sLetterBoxSize; +static U8 sLetterBoxAlpha = 255; +F32 sFullScreenGlareIntensity; // Needs to be initialized + +static _xFadeData mFade; +xGlare sGlare[10]; + +extern RwGlobals* RwEngineInstance; +extern RwInt32 RwEngineGetCurrentVideoMode(void); +extern RwVideoMode* RwEngineGetVideoModeInfo(RwVideoMode* modeinfo, RwInt32 modeIndex); + +void xScrFxInit() +{ + xScrFxFadeInit(); + xScrFxLetterBoxInit(); + xScrFXGlareInit(); + iScrFxInit(); +} + +void xScrFxReset() +{ + xScrFXGlareReset(); +} + +void xScrFxUpdate(RwCamera* cam, F32 dt) +{ + iScrFxBegin(); + xScrFxUpdateFade(cam, dt); + xScrFxUpdateLetterBox(cam, dt); + xScrFXGlareUpdate(dt); + xScrFxDistortionUpdate(dt); +} + +void xScrFxRender(RwCamera* cam) +{ + iScrFxBegin(); + xScrFxDistortionRender((RwCamera*)RwEngineInstance->curCamera); + if (g_debugRenderSafeArea != '\0') + { + xScrFxDrawSafeArea(); + } + iScrFxEnd(); +} + +void xScrFxDrawScreenSizeRectangle() +{ + // I honestly dont know how to complete this function + // FIXME: First 2 params of xScrFxDrawBox seem to be correct + // The rest of them confuse me. + + RwVideoMode video_mode; + + F32 x2 = 0; + F32 y2 = 0; + U8 red = 0; + U8 green = 0; + U8 blue = 0; + U8 alpha = 255; + F32 ushift = 0; + F32 vshift = 0; + + S32 mode = RwEngineGetCurrentVideoMode(); + RwEngineGetVideoModeInfo(&video_mode, mode); + xScrFxDrawBox((F32)video_mode.width, (F32)video_mode.height, x2, y2, red, green, blue, alpha, + ushift, vshift); +} + +void xScrFxFadeInit() +{ + memset(&mFade, 0, 0x1c); +} + +void InterpCol(F32 unk, U8 unk1, U8 unk2) +{ +} + +void xScrFxFade(iColor_tag* base, iColor_tag* dest, F32 seconds, void (*callback)(), S32 hold) +{ + mFade.active = 1; + base->operator=(*(iColor_tag*)dest); +} + +void xScrFxStopFade() +{ + mFade.active = 0; +} + +S32 xScrFxIsFading() +{ + return mFade.active; +} + +void xScrFxLetterBoxInit() +{ + mLetterboxO = 0.0f; + mLetterboxTO = 0.0f; +} + +void xScrFxLetterboxReset() +{ + mLetterboxO = 0.0f; + mLetterboxTO = 0.0f; +} + +void xScrFxLetterBoxSetSize(F32 size) +{ + sLetterBoxSize = size; +} + +void xScrFxLetterBoxSetAlpha(U8 alpha) +{ + sLetterBoxAlpha = alpha; +} + +void xScrFxLetterbox(S32 enable) +{ + if (zMenuRunning() != 0) + { + enable = 0; + } + if (enable != 0) + { + mLetterboxTO = sLetterBoxSize; + } + else + { + mLetterboxTO = 0.0f; + } +} + +S32 xScrFxIsLetterbox() +{ + return (((mLetterboxTO > 0.0f) << 2) << 0x1c) >> 0x1e; +} + void xScrFxDistortionAdd(xVec3*, xVec3*, S32) { } @@ -9,3 +148,17 @@ void xScrFxDistortionAdd(xVec3*, xVec3*, S32) void xScrFxDistortionRender(RwCamera*) { } + +void xScrFXGlareInit() +{ + sGlare->flags = 0; + for (S32 i = 1; i < 10; i++) + { + sGlare[i].flags = 0; + } +} + +void xScrFXGlareReset() +{ + xScrFXGlareInit(); +} diff --git a/src/SB/Core/x/xScrFx.h b/src/SB/Core/x/xScrFx.h index 6760b961b..b550c3152 100644 --- a/src/SB/Core/x/xScrFx.h +++ b/src/SB/Core/x/xScrFx.h @@ -3,24 +3,67 @@ #include "xCamera.h" #include "iColor.h" +#include "iScrFX.h" +#include "zMenu.h" #include +#include -void xScrFxInit (); -void xScrFxLetterBoxSetSize(F32); -void xScrFxLetterBoxSetAlpha(U8); +struct _xFadeData +{ + S32 active; // offset 0x0, size 0x4 + S32 hold; // offset 0x4, size 0x4 + iColor_tag src; // offset 0x8, size 0x4 + iColor_tag dest; // offset 0xC, size 0x4 + F32 time_passed; // offset 0x10, size 0x4 + F32 time_total; // offset 0x14, size 0x4 + void (*cb)(); // offset 0x18, size 0x4 +}; + +struct xGlare +{ + S32 flags; // offset 0x0, size 0x4 + xVec3 pos; // offset 0x4, size 0xC + F32 intensity; // offset 0x10, size 0x4 + F32 intensityFadeRate; // offset 0x14, size 0x4 + F32 lifetime; // offset 0x18, size 0x4 + F32 size; // offset 0x1C, size 0x4 + RwRGBAReal col; // offset 0x20, size 0x10 + RwRaster* raster; // offset 0x30, size 0x4 +}; + +void xScrFxInit(); +void xScrFxReset(); void xScrFxUpdate(RwCamera* cam, F32 dt); void xScrFxRender(RwCamera*); void xScrFxDrawScreenSizeRectangle(); -void xScrFxFade(iColor_tag* base, iColor_tag* dest, F32 seconds, void (*callback)(), - S32 hold); -S32 xScrFxIsLetterbox(); +void xScrFxFadeInit(); +void InterpCol(F32, U8, U8); +void xScrFxFade(iColor_tag* base, iColor_tag* dest, F32 seconds, void (*callback)(), S32 hold); +void xScrFxStopFade(); +S32 xScrFxIsFading(); +void xScrFxUpdateFade(F32 seconds); +void xScrFxUpdateFade(RwCamera* cam, F32 seconds); +void xScrFxLetterBoxInit(); void xScrFxLetterboxReset(); -S32 xScrFXGlareAdd(xVec3* pos, F32 life, F32 intensity, F32 size, F32 r, - F32 g, F32 b, F32 a, RwRaster* raster); +void xScrFxLetterBoxSetSize(F32); +void xScrFxLetterBoxSetAlpha(U8); +void xScrFxLetterbox(S32 enable); +void xScrFxUpdateLetterBox(F32 seconds); +void xScrFxUpdateLetterBox(RwCamera* cam, F32 seconds); +S32 xScrFxIsLetterbox(); +void xScrFxDrawSafeArea(); +void xScrFxDistortionAdd(xVec3*, xVec3*, S32); +static void xScrFxDistortionUpdate(F32 dt); +static void xScrFxDistortionRender(RwCamera*); +void xScrFXGlareInit(); +void xScrFXGlareReset(); +S32 xScrFXGlareAdd(xVec3* pos, F32 life, F32 intensity, F32 size, F32 r, F32 g, F32 b, F32 a, + RwRaster* raster); +void xScrFXGlareUpdate(F32); // Return type may be wrong, Not in dwarf void xScrFXFullScreenGlareRender(); void xScrFXGlareRender(xCamera* cam); -void xScrFxLetterbox(S32 enable); -void xScrFxReset(); +void xScrFxDrawBox(F32 x1, F32 y1, F32 x2, F32 y2, U8 red, U8 green, U8 blue, U8 alpha, F32 ushift, + F32 vshift); #endif diff --git a/src/SB/Game/zMenu.h b/src/SB/Game/zMenu.h index 94efeea52..30a2cac3c 100644 --- a/src/SB/Game/zMenu.h +++ b/src/SB/Game/zMenu.h @@ -3,6 +3,7 @@ #include +S32 zMenuRunning(); U32 zMenuUpdateMode(); U32 zMenuIsPaused(); S32 zMenuLoopContinue(); diff --git a/src/SB/Game/zTalkBox.cpp b/src/SB/Game/zTalkBox.cpp index bb168d7bc..96c1c8c6b 100644 --- a/src/SB/Game/zTalkBox.cpp +++ b/src/SB/Game/zTalkBox.cpp @@ -5,23 +5,102 @@ namespace { - struct SharedTalkboxState - { - void* padding[2]; // FIXME: variables not verified - ztalkbox* active; - U8 unkC[0x8D48 - 0xC]; - U32 unk8D48; - U8 unk8D4C[0x8D78 - 0x8D4C]; - U8 unk8D78; - U8 unk8D79; - U8 unk8D7A; - }; // size: 0x8E9C? - - SharedTalkboxState shared; + shared_type shared; void stop_audio_effect(); - void deactivate() { + void speak_stop() + { + if (shared.speak_npc != NULL) + { + shared.speak_npc->SpeakStop(); + shared.speak_npc = NULL; + } + + if (shared.speak_player != 0) + { + zEntPlayerSpeakStop(); + shared.speak_player = 0; + } + } + + static void trigger(U32 event) + { + // shared.delay_events = 0; // -0x7286 + // shared.triggered._first = 0; // -0x7280 + + if (shared.delay_events == 0) + { + zEntEvent(shared.active, shared.active, event); + } + else + { + shared.triggered.push_back(); + } + } + + void trigger_pads(U32 pressed) + { + if ((pressed & 0x10) != 0) + { + trigger(73); + } + if ((pressed & 0x40) != 0) + { + trigger(74); + } + if ((pressed & 0x80) != 0) + { + trigger(76); + } + if ((pressed & 0x20) != 0) + { + trigger(75); + } + if ((pressed & 1) != 0) + { + trigger(71); + } + if ((pressed & 2) != 0) + { + trigger(72); + } + if ((pressed & 0x1000) != 0) + { + trigger(69); + } + if ((pressed & 0x2000) != 0) + { + trigger(70); + } + if ((pressed & 0x100) != 0) + { + trigger(67); + } + if ((pressed & 0x200) != 0) + { + trigger(68); + } + if ((pressed & 0x10000) != 0) + { + trigger(63); + } + if ((pressed & 0x20000) != 0) + { + trigger(65); + } + if ((pressed & 0x40000) != 0) + { + trigger(66); + } + if ((pressed & 0x80000) != 0) + { + trigger(64); + } + } + + void deactivate() + { stop_audio_effect(); ztalkbox* active = shared.active; @@ -46,91 +125,93 @@ namespace // Equivalent: see fixme S32 cb_dispatch(xBase*, xBase* to, U32 event, const F32* argf, xBase*) { - shared.unk8D7A = 1; + //shared.unk8D7A = 1; ztalkbox& talkbox = *(ztalkbox*)to; switch (event) { - case 10: - case 88: - talkbox.reset(); - break; - case 4: - case 504: - talkbox.hide(); - break; - case 3: - case 503: - talkbox.show(); - break; - case 335: { - U32 textID = ((U32*)argf == NULL) ? 0 : *(U32*)argf; - talkbox.start_talk(textID, NULL, NULL); - flush_triggered(); - break; + case 10: + case 88: + talkbox.reset(); + break; + case 4: + case 504: + talkbox.hide(); + break; + case 3: + case 503: + talkbox.show(); + break; + case 335: + { + U32 textID = ((U32*)argf == NULL) ? 0 : *(U32*)argf; + talkbox.start_talk(textID, NULL, NULL); + flush_triggered(); + break; + } + case 336: + talkbox.stop_talk(); + flush_triggered(); + break; + case 352: + if (argf == NULL) + { + stop_wait(talkbox, NULL, 0); + } + else + { + stop_wait(talkbox, argf, 4); + } + flush_triggered(); + break; + case 334: + if ((U32*)argf != NULL) + { + talkbox.set_text(*(U32*)argf); } - case 336: - talkbox.stop_talk(); - flush_triggered(); - break; - case 352: - if (argf == NULL) - { - stop_wait(talkbox, NULL, 0); - } - else - { - stop_wait(talkbox, argf, 4); - } - flush_triggered(); - break; - case 334: - if ((U32*)argf != NULL) - { - talkbox.set_text(*(U32*)argf); - } - break; - case 338: - if ((U32*)argf != NULL) - { - talkbox.add_text(*(U32*)argf); - } - break; - case 339: - talkbox.clear_text(); - break; - - // FIXME: Figure out the right no-op cases - case 75: - case 76: - case 342: - case 343: - case 344: - case 345: - case 346: - case 347: - case 348: - case 349: - case 350: - case 351: - case 353: - case 356: - case 357: - case 358: - case 359: - // case 452: - // case 453: - // case 454: - case 465: - case 466: - break; + break; + case 338: + if ((U32*)argf != NULL) + { + talkbox.add_text(*(U32*)argf); + } + break; + case 339: + talkbox.clear_text(); + break; + + // FIXME: Figure out the right no-op cases + case 75: + case 76: + case 342: + case 343: + case 344: + case 345: + case 346: + case 347: + case 348: + case 349: + case 350: + case 351: + case 353: + case 356: + case 357: + case 358: + case 359: + // case 452: + // case 453: + // case 454: + case 465: + case 466: + break; } - shared.unk8D7A = 0; + //shared.unk8D7A = 0; return 1; } - char* load_text(U32 id) { + char* load_text(U32 id) + { if (id == 0) { return NULL; @@ -146,7 +227,7 @@ namespace // HACK return (char*)(asset) + 4; } -} +} // namespace void ztalkbox::load(const asset_type& tasset) { @@ -191,11 +272,33 @@ void ztalkbox::load(const asset_type& tasset) void ztalkbox::reset() { flag.visible = true; - if (shared.active == this) { + if (shared.active == this) + { deactivate(); } } +namespace +{ + + struct state_type + { + state_enum type; + + void start(); + void stop(); + }; + + void state_type::start() + { + } + + void state_type::stop() + { + } + +} // namespace + void ztalkbox::clear_text() { set_text((const char*)NULL); @@ -213,7 +316,7 @@ void ztalkbox::stop_wait(U32 unk) { if (shared.active == this) { - shared.unk8D48 |= unk; + //shared.unk8D48 |= unk; } } @@ -231,10 +334,10 @@ void ztalkbox::show() prompt_box->activate(); } - if (shared.unk8D78 != 0 && prompt.quit != 0 && quit_box != NULL) - { - quit_box->activate(); - } + // if (shared.unk8D78 != 0 && prompt.quit != 0 && quit_box != NULL) + // { + // quit_box->activate(); + // } } void ztalkbox::hide() @@ -256,3 +359,9 @@ ztalkbox* ztalkbox::get_active() { return shared.active; } + +void ztalkbox::permit(U32 add_flags, U32 remove_flags) +{ + shared.permit &= ~remove_flags; + shared.permit |= add_flags; +} diff --git a/src/SB/Game/zTalkBox.h b/src/SB/Game/zTalkBox.h index e7c75e60c..8f41492af 100644 --- a/src/SB/Game/zTalkBox.h +++ b/src/SB/Game/zTalkBox.h @@ -4,9 +4,29 @@ #include "zTextBox.h" #include "zNPCTypeCommon.h" #include "xIni.h" +#include "containers.h" +#include "zEntPlayer.h" #include "xScene.h" +enum state_enum +{ + STATE_INVALID = -1, + BEGIN_STATE = 0, + STATE_START = 1, + STATE_NEXT = 2, + STATE_WAIT = 3, + STATE_STOP = 4, + END_STATE = 5, + MAX_STATE = 5, +}; + +enum query_enum +{ + Q_SKIP, + Q_YESNO +}; + struct ztalkbox : xBase { struct asset_type : xDynAsset @@ -106,4 +126,155 @@ struct ztalkbox : xBase void hide(); }; +struct state_type +{ + state_enum type; +}; + +struct jot; + +struct callback +{ + void (*render)(jot&, xtextbox&, F32, F32); + void (*layout_update)(jot&, xtextbox&, xtextbox&); + void (*render_update)(jot&, xtextbox&, xtextbox&); +}; + +struct split_tag +{ + substr tag; + substr name; + substr action; + substr value; +}; + +struct tag_type +{ + substr name; + void (*parse_tag)(jot&, xtextbox&, xtextbox&, split_tag&); + void (*reset_tag)(jot&, xtextbox&, xtextbox&, split_tag&); + void* context; +}; + +struct jot +{ + substr s; + + struct + { + // Offset: 0x8 + bool invisible : 1; // bit 24 + bool ethereal : 1; // bit 25 + bool merge : 1; // bit 26 + bool word_break : 1; // bit 27 + bool word_end : 1; // bit 28 + bool line_break : 1; // bit 29 + bool stop : 1; // bit 30 + bool tab : 1; // bit 31 + + // Offset: 0x9 + bool insert : 1; // bit 24 + bool dynamic : 1; // bit 25 + bool page_break : 1; // bit 26 + bool stateful : 1; // bit 27 + U16 dummy : 4; // bits 28-31 + } flag; + // Offset: 0xC + U16 context_size; + + // Offset: 0x10 + void* context; + basic_rect bounds; + basic_rect render_bounds; + callback* cb; + tag_type* tag; + + void intersect_flags(const jot& other); + void reset_flags(); +}; + +struct jot_line +{ + basic_rect bounds; + F32 baseline; + U32 first; + U32 last; + U8 page_break; +}; + +struct layout +{ + xtextbox tb; // offset 0x0, size 0x68 + jot _jots[512]; // offset 0x68, size 0x7000 + U32 _jots_size; // offset 0x7068, size 0x4 + jot_line _lines[128]; // offset 0x706C, size 0x1000 + U32 _lines_size; // offset 0x806C, size 0x4 + U8 context_buffer[1024]; // offset 0x8070, size 0x400 + U32 context_buffer_size; // offset 0x8470, size 0x4 + U16 dynamics[64]; // offset 0x8474, size 0x80 + U32 dynamics_size; // offset 0x84F4, size 0x4 +}; + +struct wait_context +{ + struct + { + U8 time : 1; // offset 0x0, size 0x1 + U8 prompt : 1; // offset 0x0, size 0x1 + U8 sound : 1; // offset 0x0, size 0x1 + U8 event : 1; // offset 0x0, size 0x1 + U16 pad : 12; // offset 0x0, size 0x2 + } type; // offset 0x0, size 0x2 + U8 need; // offset 0x2, size 0x1 + F32 delay; // offset 0x4, size 0x4 + U32 event_mask; // offset 0x8, size 0x4 + query_enum query; // offset 0xC, size 0x4 +}; + +struct sound_queue +{ + U32 _playing[5]; + S32 head; + S32 tail; +}; + +struct trigger_pair +{ + ztalkbox* origin; + U32 event; +}; + +struct shared_type +{ + S32 flags; // offset 0x0, size 0x4 + U32 permit; // offset 0x4, size 0x4 + ztalkbox* active; // offset 0x8, size 0x4 + state_type* state; // offset 0xC, size 0x4 + state_type* states[5]; // offset 0x10, size 0x14 + layout lt; // offset 0x24, size 0x84F8 + S32 begin_jot; // offset 0x851C, size 0x4 + S32 end_jot; // offset 0x8520, size 0x4 + S32 page_end_jot; // offset 0x8524, size 0x4 + wait_context wait; // offset 0x8528, size 0x10 + wait_context auto_wait; // offset 0x8538, size 0x10 + U32 wait_event_mask; // offset 0x8548, size 0x4 + F32 prompt_delay; // offset 0x854C, size 0x4 + F32 quit_delay; // offset 0x8550, size 0x4 + U8 prompt_ready; // offset 0x8554, size 0x1 + U8 quit_ready; // offset 0x8555, size 0x1 + U8 stream_locked[2]; // offset 0x8556, size 0x2 + S32 next_stream; // offset 0x8558, size 0x4 + // The below builds perfectly fine, unsure if its 100% correct though + sound_queue<4> sounds; // offset 0x855C, size 0x1C + U8 allow_quit; // offset 0x8578, size 0x1 + U8 quitting; // offset 0x8579, size 0x1 + U8 delay_events; // offset 0x857A, size 0x1 + callback* cb; // offset 0x857C, size 0x4 + // The below builds perfectly fine, unsure if its 100% correct though + fixed_queue triggered; // offset 0x8580, size 0x110 + F32 volume; // offset 0x8690, size 0x4 + zNPCCommon* speak_npc; // offset 0x8694, size 0x4 + U32 speak_player; // offset 0x8698, size 0x4 +}; + #endif From 4e22741c0bcdf042f883ffbc9a30faf8c0fe3b77 Mon Sep 17 00:00:00 2001 From: Steven Casper Date: Mon, 1 Sep 2025 05:03:16 +0000 Subject: [PATCH 05/13] zAssetTypes done for now (#588) * Progress * zAssetTypes done for now * Mark zAssetTypes equivalent --- configure.py | 2 +- src/SB/Core/x/xAnim.h | 15 +- src/SB/Core/x/xSnd.h | 6 + src/SB/Game/zAssetTypes.cpp | 266 +++++++++++++++++++++++++++++++-- src/SB/Game/zAssetTypes.h | 53 +++++++ src/SB/Game/zEntCruiseBubble.h | 4 +- src/SB/Game/zNPCTypeCommon.h | 3 + 7 files changed, 326 insertions(+), 23 deletions(-) diff --git a/configure.py b/configure.py index c385f046f..60438f4ee 100644 --- a/configure.py +++ b/configure.py @@ -421,7 +421,7 @@ def MatchingFor(*versions): Object(Matching, "SB/Core/x/xVec3.cpp"), Object(NonMatching, "SB/Game/zActionLine.cpp"), Object(Equivalent, "SB/Game/zAnimList.cpp"), - Object(NonMatching, "SB/Game/zAssetTypes.cpp"), + Object(Equivalent, "SB/Game/zAssetTypes.cpp", extra_cflags=["-sym on"]), Object(NonMatching, "SB/Game/zCamera.cpp"), Object(Matching, "SB/Game/zConditional.cpp"), Object(NonMatching, "SB/Game/zCutsceneMgr.cpp"), diff --git a/src/SB/Core/x/xAnim.h b/src/SB/Core/x/xAnim.h index d9a5823f6..93d8a429c 100644 --- a/src/SB/Core/x/xAnim.h +++ b/src/SB/Core/x/xAnim.h @@ -65,7 +65,7 @@ struct xAnimState F32 Speed; xAnimFile* Data; xAnimEffect* Effects; - + // 0x20 xAnimTransitionList* Default; xAnimTransitionList* List; @@ -177,10 +177,11 @@ struct xAnimPlay void (*BeforeAnimMatrices)(xAnimPlay*, xQuat*, xVec3*, S32); }; -class AnimTableList { // size: 0xC +class AnimTableList +{ // size: 0xC public: - char * name; // offset 0x0, size 0x4 - class xAnimTable * (* constructor)(); // offset 0x4, size 0x4 + char* name; // offset 0x0, size 0x4 + class xAnimTable* (*constructor)(); // offset 0x4, size 0x4 unsigned int id; // offset 0x8, size 0x4 }; @@ -188,6 +189,9 @@ void xAnimInit(); void xAnimTempTransitionInit(U32 count); xAnimFile* xAnimFileNew(void* rawData, const char* name, U32 flags, xAnimFile** linkedList); xAnimTable* xAnimTableNew(const char* name, xAnimTable** linkedList, U32 userFlags); +xAnimFile* xAnimFileNewBilinear(void** rawData, const char* name, U32 flags, xAnimFile** linkedList, + U32 numX, U32 numY); +void xAnimFileSetTime(xAnimFile* data, float duration, float timeOffset); xAnimState* xAnimTableNewState(xAnimTable* table, const char* name, U32 flags, U32 userFlags, F32 speed, F32* boneBlend, F32* timeSnap, F32 fadeRecip, U16* fadeOffset, void* callbackData, @@ -199,6 +203,8 @@ xAnimTransition* xAnimTableNewTransition(xAnimTable* table, const char* source, xAnimTransitionCallback callback, U32 flags, U32 userFlags, F32 srcTime, F32 destTime, U16 priority, U16 queuePriority, F32 blendRecip, U16* blendOffset); +xAnimEffect* xAnimStateNewEffect(xAnimState* state, U32 flags, F32 startTime, F32 endTime, + xAnimEffectCallback callback, U32 userDataSize); void xAnimDefaultBeforeEnter(xAnimPlay* play, xAnimState* state); void xAnimPoolInit(xMemPool* pool, U32 count, U32 singles, U32 blendFlags, U32 effectMax); xAnimPlay* xAnimPoolAlloc(xMemPool* pool, void* object, xAnimTable* table, @@ -225,5 +231,4 @@ inline F32 xAnimFileRawTime(xAnimFile* data, float time) return data->TimeOffset + time; } - #endif diff --git a/src/SB/Core/x/xSnd.h b/src/SB/Core/x/xSnd.h index 771ef4b0d..295823de8 100644 --- a/src/SB/Core/x/xSnd.h +++ b/src/SB/Core/x/xSnd.h @@ -155,4 +155,10 @@ void xSndSetPitch(U32 snd, F32 pitch); void xSndSetCategoryVol(sound_category category, F32 vol); void xSndSetExternalCallback(void (*callback)(U32)); +inline U32 xSndPlay3D(U32 id, F32 vol, F32 pitch, U32 priority, U32 flags, xEnt* ent, F32 radius, + sound_category category, F32 delay) +{ + return xSndPlay3D(id, vol, pitch, priority, flags, ent, radius / 4.0f, radius, category, delay); +} + #endif diff --git a/src/SB/Game/zAssetTypes.cpp b/src/SB/Game/zAssetTypes.cpp index c4ff20f4e..e93daee27 100644 --- a/src/SB/Game/zAssetTypes.cpp +++ b/src/SB/Game/zAssetTypes.cpp @@ -1,15 +1,16 @@ #include "zAssetTypes.h" +#include "xAnim.h" #include "xstransvc.h" #include "xDebug.h" #include "xEnv.h" #include "xJSP.h" +#include "xMorph.h" #include #include #include #include -#include static void* Curve_Read(void* param_1, U32 param_2, void* indata, U32 insize, U32* outsize); static void* ATBL_Read(void* param_1, U32 param_2, void* indata, U32 insize, U32* outsize); @@ -219,7 +220,7 @@ static char* jsp_shadow_hack_textures[] = { "glass_broken", "ground_path_alpha", }; -static char** jsp_shadow_hack_end_textures = &jsp_shadow_hack_textures[4]; +static char** jsp_shadow_hack_end_textures = &jsp_shadow_hack_textures[5]; struct AnimTableList animTable[33] = { { "ZNPC_AnimTable_Test", ZNPC_AnimTable_Test, 0 }, @@ -344,7 +345,7 @@ static void jsp_shadow_hack(xJSPHeader* header) RpClumpForAllAtomics(header->clump, jsp_shadow_hack_atomic_cb, &context); } -static xAnimTable* (*tableFuncList[48])() = { +static xAnimTable* (*tableFuncList[])() = { zEntPlayer_AnimTable, ZNPC_AnimTable_Common, zPatrick_AnimTable, @@ -389,7 +390,7 @@ static xAnimTable* (*tableFuncList[48])() = { ZNPC_AnimTable_NightLight, ZNPC_AnimTable_HazardStd, ZNPC_AnimTable_FloatDevice, - anim_table, // Cruise Bubble anim table based on PS2 DWARF data + cruise_bubble::anim_table, // Cruise Bubble anim table based on PS2 DWARF data ZNPC_AnimTable_BossSandyScoreboard, zEntPlayer_TreeDomeSBAnimTable, NULL, @@ -504,14 +505,255 @@ void FootstepHackSceneEnter() s_patFootSoundB = xStrHash("Pat_run_rock_dryR"); } -static U8 dummyEffectCB(U32, xAnimActiveEffect*, xAnimSingle*, void*) +static U32 dummyEffectCB(U32, xAnimActiveEffect*, xAnimSingle*, void*) { return 0; } -static void* ATBL_Read(void*, unsigned int, void*, unsigned int, unsigned int*) +static U32 soundEffectCB(U32 cbenum, xAnimActiveEffect* acteffect, xAnimSingle* single, + void* object) { - return NULL; + U32 sndhandle = 0; + U32 vil_SID = 0; + S32 vil_result; + + if (cbenum == 1) + { + xEnt* ent_tmp = (xEnt*)object; + zAnimFxSound* snd = (zAnimFxSound*)(acteffect->Effect + 1); + if (ent_tmp == NULL) + { + vil_result = 0; + } + else if (ent_tmp->baseType == eBaseTypeNPC) + { + vil_result = ((zNPCCommon*)ent_tmp)->SndPlayFromAFX(snd, &vil_SID); + } + else + { + vil_result = 0; + } + + if (vil_result > 0) + { + sndhandle = vil_SID; + } + else if (vil_result < 0) + { + sndhandle = 0; + } + else + { + U32 id = snd->ID; + U32 newId; + F32 volFactor; + + static U32 footSelector = 0; + footSelector++; + if (id == 0x42B584CB || id == 0x56E1F71E || id == 0x331BDF8F) + { + newId = 0; + volFactor = 1.0f; + + switch (id) + { + case 0x42B584CB: + { + newId = footSelector % 2 ? s_sbFootSoundA : s_sbFootSoundB; + volFactor = 0.6f; + break; + } + case 0x56E1F71E: + { + newId = footSelector % 2 ? s_scFootSoundA : s_scFootSoundB; + volFactor = 0.4f; + break; + } + case 0x331BDF8F: + { + newId = footSelector % 2 ? s_patFootSoundA : s_patFootSoundB; + volFactor = 0.6f; + break; + } + } + volFactor *= 0.65f; + sndhandle = xSndPlay(newId, snd->vol * 0.77f * volFactor, snd->pitch, snd->priority, + snd->flags, 0, SND_CAT_GAME, 0.0f); + } + else + { + sndhandle = xSndPlay3D(snd->ID, snd->vol * 0.77f, snd->pitch, snd->priority, + snd->flags, (xEnt*)object, snd->radius, SND_CAT_GAME, 0.0f); + } + } + } + if (cbenum == 3) + { + xSndStop(acteffect->Handle); + } + + return sndhandle; +} + +static U32 (*effectFuncList[])(U32, xAnimActiveEffect*, xAnimSingle*, void*) = { dummyEffectCB, + soundEffectCB }; + +static void* FindAssetCB(U32 ID, char*) +{ + U32 size; + return xSTFindAsset(ID, &size); +} + +static xAnimTable* Anim_ATBL_getTable(xAnimTable* (*constructor)()); +static void* ATBL_Read(void*, U32, void* indata, U32 param_4, U32* outsize) +{ + U32 i; + U32 j; + U32 debugNum = 0; + U32 tmpsize; + + xAnimTable* table; + xAnimState* astate; + xAnimTransition* atran; + U8* zaBytes; + + xAnimAssetTable* zaTbl = (xAnimAssetTable*)indata; + void** zaRaw = (void**)(zaTbl + 1); + xAnimAssetFile* zaFile = (xAnimAssetFile*)(zaRaw + zaTbl->NumRaw); + xAnimAssetState* zaState = + (xAnimAssetState*)((U32)zaFile + zaTbl->NumFiles * sizeof(xAnimAssetFile)); + + for (i = 0; i < zaTbl->NumRaw; ++i) + { + zaRaw[i] = xSTFindAsset(*(U32*)&zaRaw[i], &tmpsize); + } + + for (i = 0; i < zaTbl->NumRaw; ++i) + { + if (zaRaw[i] == NULL) + { + for (j = 0; j < zaTbl->NumRaw; ++j) + { + if (zaRaw[j] != NULL) + { + zaRaw[i] = zaRaw[j]; + break; + } + } + } + } + + for (i = 0; i < zaTbl->NumRaw; ++i) + { + if (*(U32*)zaRaw[i] == 'QSPM') + { + xMorphSeqSetup(zaRaw[i], FindAssetCB); + } + } + + for (i = 0; i < zaTbl->NumFiles; ++i) + { + zaFile[i].RawData = (void**)((U32)zaFile[i].RawData + (U32)zaTbl); + for (S32 k = 0; k < zaFile[i].NumAnims[0] * zaFile[i].NumAnims[1]; ++k) + { + zaFile[i].RawData[k] = zaRaw[(U32)zaFile[i].RawData[k]]; + } + } + + xAnimFile** fList = (xAnimFile**)zaFile; + for (i = 0; i < zaTbl->NumFiles; ++i) + { + fList[i] = xAnimFileNewBilinear(zaFile[i].RawData, "", zaFile[i].FileFlags, NULL, + zaFile[i].NumAnims[0], zaFile[i].NumAnims[1]); + if (zaFile[i].TimeOffset >= 0.0f) + { + xAnimFileSetTime(fList[i], zaFile[i].Duration, zaFile[i].TimeOffset); + } + } + + xAnimTable* (*constructor)() = NULL; + if (zaTbl->ConstructFunc < sizeof(tableFuncList) / sizeof(xAnimTable * (*)())) + { + constructor = tableFuncList[zaTbl->ConstructFunc]; + } + else + { + for (S32 i = 0; i < sizeof(animTable) / sizeof(AnimTableList); ++i) + { + if (zaTbl->ConstructFunc == animTable[i].id) + { + constructor = animTable[i].constructor; + break; + } + } + } + + gxAnimUseGrowAlloc = true; + + table = Anim_ATBL_getTable(constructor); + + char tmpstr[32]; + for (i = 0; i < zaTbl->NumStates; ++i) + { + astate = xAnimTableAddFileID(table, fList[zaState[i].FileIndex], zaState[i].StateID, + zaState[i].SubStateID, zaState[i].SubStateCount); + + if (astate == NULL) + { + sprintf(tmpstr, "Debug%02d", debugNum++); + astate = xAnimTableNewState(table, tmpstr, 0x20, 0x80000000, 1.0f, NULL, NULL, 0.0f, + NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); + atran = xAnimTableNewTransition(table, tmpstr, NULL, NULL, NULL, 0x10, 0, 0.0f, 0.0f, 0, + 0, 0.2f, NULL); + atran->Dest = table->StateList; + xAnimTableAddFileID(table, fList[zaState[i].FileIndex], astate->ID, 0, 0); + } + astate->Speed = zaState[i].Speed; + } + + xAnimFile* foundFile = NULL; + for (astate = table->StateList; astate != NULL; astate = astate->Next) + { + if (foundFile == NULL && astate->Data != NULL) + { + foundFile = astate->Data; + } + } + for (astate = table->StateList; astate != NULL; astate = astate->Next) + { + if (astate->Data == NULL) + { + astate->Data = foundFile; + astate->UserFlags |= 0x40000000; + } + } + + for (i = 0; i < zaTbl->NumStates; ++i) + { + if (zaState[i].EffectCount != 0) + { + xAnimState* state = xAnimTableGetStateID(table, zaState[i].StateID); + xAnimAssetEffect* zaEffect = (xAnimAssetEffect*)((U32)zaTbl + zaState[i].EffectOffset); + + if (state != NULL) + { + for (j = 0; j < zaState[i].EffectCount; ++j) + { + xAnimEffect* effect = + xAnimStateNewEffect(state, zaEffect->Flags, zaEffect->StartTime, + zaEffect->EndTime, effectFuncList[zaEffect->EffectType], + zaEffect->UserDataSize); + memcpy(effect + 1, zaEffect + 1, zaEffect->UserDataSize); + + zaEffect = (xAnimAssetEffect*)(U32(zaEffect) + zaEffect->UserDataSize) + 1; + } + } + } + } + + gxAnimUseGrowAlloc = false; + *outsize = sizeof(xAnimTable); + return table; } static void Anim_Unload(void*, U32) @@ -523,9 +765,9 @@ static void LightKit_Unload(void* userdata, U32 b) xLightKit_Destroy((xLightKit*)userdata); } -static void Anim_ATBL_getTable(xAnimTable* (*param)(void)) +static xAnimTable* Anim_ATBL_getTable(xAnimTable* (*constructor)()) { - *param(); + return constructor(); } static void MovePoint_Unload(void* userdata, U32 b) @@ -556,9 +798,3 @@ static void* SndInfoRead(void* param_1, U32 param_2, void* indata, U32 insize, U return __dest; } - -U32 xSndPlay3D(U32 id, F32 vol, F32 pitch, U32 priority, U32 flags, xEnt* ent, F32 radius, - sound_category category, F32 delay) -{ - return xSndPlay3D(id, vol, pitch, priority, flags, ent, radius / 4.0f, radius, category, delay); -} diff --git a/src/SB/Game/zAssetTypes.h b/src/SB/Game/zAssetTypes.h index b47b18573..c7fe6d565 100644 --- a/src/SB/Game/zAssetTypes.h +++ b/src/SB/Game/zAssetTypes.h @@ -40,6 +40,59 @@ class HackModelRadius F32 radius; }; +// Note (Square): I'm not sure if this should be in this header but it looks to only be used in one other place +struct zAnimFxSound +{ + U32 ID; + F32 vol; + F32 pitch; + U32 priority; + U32 flags; + F32 radius; +}; + +struct xAnimAssetTable +{ + U32 Magic; + U32 NumRaw; + U32 NumFiles; + U32 NumStates; + U32 ConstructFunc; +}; + +struct xAnimAssetFile +{ + U32 FileFlags; + F32 Duration; + F32 TimeOffset; + U16 NumAnims[2]; + void** RawData; + S32 Physics; + S32 StartPose; + S32 EndPose; +}; + +struct xAnimAssetState +{ + U32 StateID; + U32 FileIndex; + U32 EffectCount; + U32 EffectOffset; + F32 Speed; + U32 SubStateID; + U32 SubStateCount; +}; + +struct xAnimAssetEffect +{ + U32 StateID; + F32 StartTime; + F32 EndTime; + U32 Flags; + U32 EffectType; + U32 UserDataSize; +}; + void zAssetStartup(); void zAssetShutdown(); void FootstepHackSceneEnter(); diff --git a/src/SB/Game/zEntCruiseBubble.h b/src/SB/Game/zEntCruiseBubble.h index 19ded2cc5..7a9c62b2a 100644 --- a/src/SB/Game/zEntCruiseBubble.h +++ b/src/SB/Game/zEntCruiseBubble.h @@ -648,8 +648,8 @@ namespace cruise_bubble bool event_handler(xBase* from, U32 event, const F32* fparam, xBase* to); xMat4x3* get_player_mat(); xMat4x3* get_missle_mat(); -} // namespace cruise_bubble + xAnimTable* anim_table(); -xAnimTable* anim_table(); +} // namespace cruise_bubble #endif diff --git a/src/SB/Game/zNPCTypeCommon.h b/src/SB/Game/zNPCTypeCommon.h index 3cbb0481d..80233c0ce 100644 --- a/src/SB/Game/zNPCTypeCommon.h +++ b/src/SB/Game/zNPCTypeCommon.h @@ -27,6 +27,8 @@ typedef struct NPCMsg; +class zAnimFxSound; + enum en_npcparm { NPC_PARM_NONE, @@ -460,6 +462,7 @@ struct zNPCCommon : xNPCBasic //Size of zNPCCommon: 0x2A0 void GiveReward(); void PlayerKiltMe(); S32 SndPlayFromSFX(xSFX* sfx, U32* sid_played); + S32 SndPlayFromAFX(zAnimFxSound* afx, U32* sid_played); S32 SndPlayRandom(en_NPC_SOUND sndtype); //U32 SndStart(U32 aid_toplay, NPCSndProp* sprop, F32 radius); S32 SndChanIsBusy(S32 flg_chan); From 8ee7ea7eefb6c244c6be1f8c5a57b6bfb57635e5 Mon Sep 17 00:00:00 2001 From: Colin Miller Date: Mon, 8 Sep 2025 22:14:38 -0400 Subject: [PATCH 06/13] Couple functions in zNPCMessenger. Misc fixes --- src/SB/Game/zDiscoFloor.cpp | 9 ++- src/SB/Game/zMain.cpp | 8 +- src/SB/Game/zNPCMessenger.cpp | 117 ++++++++++++++++++++++++++---- src/SB/Game/zNPCMessenger.h | 22 ++++-- src/SB/Game/zNPCTypeBossSB2.cpp | 82 ++++++++------------- src/SB/Game/zNPCTypeBossSandy.cpp | 73 ++++++++++++++----- src/SB/Game/zNPCTypeBossSandy.h | 2 +- src/SB/Game/zNPCTypeCommon.h | 1 + src/SB/Game/zNPCTypeKingJelly.cpp | 39 +++++++++- src/SB/Game/zNPCTypeKingJelly.h | 5 +- src/dolphin/src/si/SIBios.c | 2 +- 11 files changed, 259 insertions(+), 101 deletions(-) diff --git a/src/SB/Game/zDiscoFloor.cpp b/src/SB/Game/zDiscoFloor.cpp index 09fa33956..81a4e343c 100644 --- a/src/SB/Game/zDiscoFloor.cpp +++ b/src/SB/Game/zDiscoFloor.cpp @@ -63,13 +63,14 @@ namespace // non-matching: scheduling glow_light.kit.tagID = 'TIKL'; + glow_light.kit.lightCount = 1; glow_light.kit.lightList = glow_light.light; glow_light.light[0].type = 0x1; - glow_light.light[0].color.red = _710_2; - glow_light.light[0].color.green = _710_2; - glow_light.light[0].color.blue = _710_2; - glow_light.light[0].color.alpha = _710_2; + glow_light.light[0].color.red = 1.0; + glow_light.light[0].color.green = 1.0; + glow_light.light[0].color.blue = 1.0; + glow_light.light[0].color.alpha = 1.0; xLightKit_Prepare(&glow_light.kit); } diff --git a/src/SB/Game/zMain.cpp b/src/SB/Game/zMain.cpp index a69f9d97d..a27023305 100644 --- a/src/SB/Game/zMain.cpp +++ b/src/SB/Game/zMain.cpp @@ -596,7 +596,6 @@ void zMainMemLvlChkCB() void zLedgeAdjust(zLedgeGrabParams* params) { params->animGrab *= (1.0f / 30); - params->animGrab *= (1.0f / 30); } void zMainShowProgressBar() @@ -740,6 +739,13 @@ void zMainReadINI() void* buf; U32 size; xIniFile* ini; + uint local_18[2]; + + str = (char*)iFileLoad("SB.INI", 0, (U32*)local_18); + if (str = NULL) + { + xIniGetString(xIniParse(0, 0), "patrick.MoveSpeed", 0); + } } void zMainFirstScreen(int) diff --git a/src/SB/Game/zNPCMessenger.cpp b/src/SB/Game/zNPCMessenger.cpp index 7e8a686c6..8d80b416f 100644 --- a/src/SB/Game/zNPCMessenger.cpp +++ b/src/SB/Game/zNPCMessenger.cpp @@ -4,6 +4,8 @@ #include static NPCPSData g_postoffice; +static NPCMsg g_msgdata; +static S32 g_lockarea; NPCPSData* NPCPS_postOffice() { @@ -23,12 +25,23 @@ void zNPCMsg_SceneFinish() return zNPCMsg_SceneReset(); } -void zNPCMsg_SendMsg(en_NPC_MSG_ID, U8) +void zNPCMsg_SendMsg(en_NPC_MSG_ID msgevent /* r17 */, U32 unk0) { + static NPCMsg msg; + memset(&msg, 0, sizeof(NPCMsg)); + msg.msgid = msgevent; + msg.sendto = unk0; + zNPCMsg_SendMsg(&msg, -1.0f, 0); } -void zNPCMsg_SendMsg(en_NPC_MSG_ID, zNPCCommon*) +void zNPCMsg_SendMsg(en_NPC_MSG_ID msgevent, zNPCCommon* npc) { + static NPCMsg msg; + + memset(&msg, 0, sizeof(NPCMsg)); + msg.msgid = msgevent; + msg.sendto = npc->id; + zNPCMsg_SendMsg(&msg, -1.0f, npc); } void zNPCMsg_SendMsg(NPCMsg*, zNPCCommon*) @@ -43,34 +56,44 @@ void NPCPS_copyMsgInfo(NPCMsg*, NPCMsg*, float) { } -void NPCPS_queMessage(NPCMsg*) +void NPCPS_queMessage(NPCMsg* msg) { - // LW - 50% match - // probably a simple fix - NPCPSData* tempQue; + NPCPSData* npc; - tempQue = NPCPS_postOffice(); + npc = NPCPS_postOffice(); - XOrdAppend(((st_XORDEREDARRAY*)tempQue + 0x2), NULL); + XOrdAppend(&npc->quelist, msg); } S32 NPCPS_flagForMID(en_NPC_MSG_ID) { - return 7; + return NPC_MID_DTRON_NPCAVAIL; } -F32 NPCPS_MsgPoolInit(NPCPSData*, int) +void NPCPS_MsgPoolInit(NPCPSData* npc, S32 unk) { - return 0; + XOrdInit(&npc->quelist, unk, 0); + npc->msgblob = (NPCMsg*)xMemAlloc(gActiveHeap, unk * sizeof(NPCMsg), 0); + memset(npc->msgblob, 0, unk * sizeof(NPCMsg)); + NPCPS_MsgPoolReset(npc); } -void NPCPS_MsgPoolReset(NPCPSData*) +void NPCPS_MsgPoolReset(NPCPSData* npc) { + S32 iVar11 = npc->quelist.max; + npc->quelist.cnt = 0; + memset(npc->msgblob, 0, npc->quelist.max * sizeof(NPCMsg)); + if (0 < iVar11) + { + } } -F32 NPCPS_CltPoolInit(NPCPSData*, int) +void NPCPS_CltPoolInit(NPCPSData* npc, S32 unk) { - return 0; + XOrdInit(&npc->cltlist, unk, 0); + npc->cltblob = (NPCPSClt*)xMemAlloc(gActiveHeap, unk * 16, 0); + memset(npc->cltblob, 0, unk * 16); + NPCPS_CltPoolReset(npc); } void NPCPS_CltPoolReset(NPCPSData*) @@ -79,12 +102,78 @@ void NPCPS_CltPoolReset(NPCPSData*) void NPCPS_grabMsg() { + NPCPSData* npc = NPCPS_postOffice(); + + if (npc->msgfree == 0) + { + npc->msgfree = 0; + } } void NPCPS_freeMsg(NPCMsg*) { } +void zNPCMsg_AreaNotify(zNPCCommon* sender, en_NPC_MSG_ID msgid, F32 rad, S32 filter, + en_NPCTYPES* toNPCType) +{ + // TODO: Honestly, I dont know how to finish this. + + if (g_lockarea == 0) + { + g_lockarea = 1; + + memset(&g_msgdata, 0, sizeof(NPCMsg)); + + if (sender != NULL) + { + g_msgdata.from = NPC_MID_NONE; + } + else + { + msgid = (en_NPC_MSG_ID)'FAKE'; + } + + g_msgdata.from = 0; + g_msgdata.msgid = msgid; + g_msgdata.sendto = 0; + g_msgdata.infotype = NPC_MDAT_BLANK; + + zNPCMsg_AreaNotify(sender, &g_msgdata, rad, filter, toNPCType); + g_lockarea = 0; + } +} + +void zNPCMsg_AreaNotify(zNPCCommon* sender, en_NPC_MSG_ID msgid, F32 rad, S32 filter, + en_NPCTYPES toNPCType) +{ + // TODO: Honestly, I dont know how to finish this. + + if (g_lockarea == 0) + { + g_lockarea = 1; + + memset(&g_msgdata, 0, sizeof(NPCMsg)); + + if (sender != NULL) + { + g_msgdata.from = NPC_MID_NONE; + } + else + { + msgid = (en_NPC_MSG_ID)'FAKE'; + } + + g_msgdata.from = 0; + g_msgdata.msgid = msgid; + g_msgdata.sendto = 0; + g_msgdata.infotype = NPC_MDAT_BLANK; + + zNPCMsg_AreaNotify(sender, &g_msgdata, rad, filter, &toNPCType); + g_lockarea = 0; + } +} + void zNPCMsg_Startup() { NPCPSData* tempStartup; diff --git a/src/SB/Game/zNPCMessenger.h b/src/SB/Game/zNPCMessenger.h index 0d3d80f36..101e96056 100644 --- a/src/SB/Game/zNPCMessenger.h +++ b/src/SB/Game/zNPCMessenger.h @@ -4,14 +4,6 @@ #include "zNPCTypeCommon.h" #include "zNPCTypes.h" -void zNPCMsg_SceneReset(); -void zNPCMsg_ScenePrepare(); -void zNPCMsg_Startup(); -void zNPCMsg_Shutdown(); -// void zNPCMsg_AreaNotify(zNPCCommon* sender, en_NPC_MSG_ID msgid, F32 rad, S32 filter, -// en_NPCTYPES toNPCType); -void zNPCMsg_Timestep(xScene* xscn, F32 dt); - struct NPCMsg; struct NPCPSClt @@ -34,4 +26,18 @@ struct NPCPSData st_XORDEREDARRAY quelist; // offset 0x20, size 0x10 }; +void zNPCMsg_SceneReset(); +void zNPCMsg_ScenePrepare(); +void zNPCMsg_Startup(); +void zNPCMsg_Shutdown(); +void zNPCMsg_AreaNotify(zNPCCommon* sender, en_NPC_MSG_ID msgid, F32 rad, S32 filter, + en_NPCTYPES toNPCType); +void zNPCMsg_AreaNotify(zNPCCommon* sender, en_NPC_MSG_ID msgid, F32 rad, S32 filter, + en_NPCTYPES* toNPCType); +void zNPCMsg_AreaNotify(zNPCCommon* sender, NPCMsg* msg, F32 rad, S32 filter, + en_NPCTYPES* toNPCType); +void zNPCMsg_Timestep(xScene* xscn, F32 dt); +void NPCPS_MsgPoolReset(NPCPSData* npc); +void NPCPS_CltPoolReset(NPCPSData* npc); + #endif diff --git a/src/SB/Game/zNPCTypeBossSB2.cpp b/src/SB/Game/zNPCTypeBossSB2.cpp index 5df7f7e10..00fd2fefc 100644 --- a/src/SB/Game/zNPCTypeBossSB2.cpp +++ b/src/SB/Game/zNPCTypeBossSB2.cpp @@ -988,110 +988,86 @@ namespace xAnimTable* ZNPC_AnimTable_BossSB2() { // clang-format off - // S32 anim_list[27] = { - - // ANIM_Idle01, - // ANIM_Idle02, - // ANIM_Taunt01, - // ANIM_Hit01, - // ANIM_Hit02, - // ANIM_SmashHitLeft, - // ANIM_SmashHitRight, - // ANIM_SmackLeft01, - // ANIM_SmackRight01, - // ANIM_ChopLeftBegin, - // ANIM_ChopLeftLoop, - // ANIM_ChopLeftEnd, - // ANIM_ChopRightBegin, No longer needed? - // ANIM_ChopRightLoop, Was used instead of "ANIM_xxxxx;" right before new state - // ANIM_ChopRightEnd, - // ANIM_SwipeLeftBegin, - // ANIM_SwipeLeftLoop, - // ANIM_SwipeLeftEnd, - // ANIM_SwipeRightBegin, - // ANIM_SwipeRightLoop, - // ANIM_SwipeRightEnd, - // ANIM_ReturnIdle01, - // ANIM_KarateStart, - // ANIM_KarateLoop, - // ANIM_KarateEnd, - // ANIM_Dizzy01, - // }; + S32 anim_list[27] = { + + ANIM_Idle01, + ANIM_Idle02, + ANIM_Taunt01, + ANIM_Hit01, + ANIM_Hit02, + ANIM_SmashHitLeft, + ANIM_SmashHitRight, + ANIM_SmackLeft01, + ANIM_SmackRight01, + ANIM_ChopLeftBegin, + ANIM_ChopLeftLoop, + ANIM_ChopLeftEnd, + ANIM_ChopRightBegin, + ANIM_ChopRightLoop, + ANIM_ChopRightEnd, + ANIM_SwipeLeftBegin, + ANIM_SwipeLeftLoop, + ANIM_SwipeLeftEnd, + ANIM_SwipeRightBegin, + ANIM_SwipeRightLoop, + ANIM_SwipeRightEnd, + ANIM_ReturnIdle01, + ANIM_KarateStart, + ANIM_KarateLoop, + ANIM_KarateEnd, + ANIM_Dizzy01, + }; xAnimTable* table = xAnimTableNew("zNPCB_SB2_Karate", NULL, 0); //24 new state //15 new transition - ANIM_Idle01; xAnimTableNewState(table, g_strz_bossanim[ANIM_Idle01], 0x10, 0, 1, NULL, NULL, 0, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); - ANIM_Idle02; xAnimTableNewState(table, g_strz_bossanim[ANIM_Idle02], 0, 0, 1, NULL, NULL, 0, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); - ANIM_Taunt01; xAnimTableNewState(table, g_strz_bossanim[ANIM_Taunt01], 0, 0, 1, NULL, NULL, 0, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); - ANIM_SmackLeft01; xAnimTableNewState(table, g_strz_bossanim[ANIM_SmackLeft01], 0x20, 0, 1, NULL, NULL, 0, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); - ANIM_SmackRight01; xAnimTableNewState(table, g_strz_bossanim[ANIM_SmackRight01], 0x20, 0, 1, NULL, NULL, 0, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); - ANIM_ChopLeftBegin; xAnimTableNewState(table, g_strz_bossanim[ANIM_ChopLeftBegin], 0x20, 0, 1, NULL, NULL, 0, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); - ANIM_ChopLeftLoop; xAnimTableNewState(table, g_strz_bossanim[ANIM_ChopLeftLoop], 0, 0, 1, NULL, NULL, 0, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); - ANIM_ChopLeftEnd; xAnimTableNewState(table, g_strz_bossanim[ANIM_ChopLeftEnd], 0x20, 0, 1, NULL, NULL, 0, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); - ANIM_ChopRightBegin; xAnimTableNewState(table, g_strz_bossanim[ANIM_ChopRightBegin], 0x20, 0, 1, NULL, NULL, 0, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); - ANIM_ChopRightLoop; xAnimTableNewState(table, g_strz_bossanim[ANIM_ChopRightLoop], 0, 0, 1, NULL, NULL, 0, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); - ANIM_ChopRightEnd; xAnimTableNewState(table, g_strz_bossanim[ANIM_ChopRightEnd], 0x20, 0, 1, NULL, NULL, 0, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); - ANIM_SwipeLeftBegin; xAnimTableNewState(table, g_strz_bossanim[ANIM_SwipeLeftBegin], 0x20, 0, 1, NULL, NULL, 0, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); - ANIM_SwipeLeftLoop; xAnimTableNewState(table, g_strz_bossanim[ANIM_SwipeLeftLoop], 0x10, 0, 1, NULL, NULL, 0, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); - ANIM_SwipeLeftEnd; xAnimTableNewState(table, g_strz_bossanim[ANIM_SwipeLeftEnd], 0x20, 0, 1, NULL, NULL, 0, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); - ANIM_SwipeRightBegin; xAnimTableNewState(table, g_strz_bossanim[ANIM_SwipeRightBegin], 0x20, 0, 1, NULL, NULL, 0, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); - ANIM_SwipeRightLoop; xAnimTableNewState(table, g_strz_bossanim[ANIM_SwipeRightLoop], 0x10, 0, 1, NULL, NULL, 0, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); - ANIM_SwipeRightEnd; xAnimTableNewState(table, g_strz_bossanim[ANIM_SwipeRightEnd], 0x20, 0, 1, NULL, NULL, 0, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); - ANIM_Dizzy01; xAnimTableNewState(table, g_strz_bossanim[ANIM_Dizzy01], 0x10, 0, 1, NULL, NULL, 0, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); - ANIM_Hit01; xAnimTableNewState(table, g_strz_bossanim[ANIM_Hit01], 0, 0, 1, NULL, NULL, 0, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); - ANIM_Hit02; xAnimTableNewState(table, g_strz_bossanim[ANIM_Hit02], 0, 0, 1, NULL, NULL, 0, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); - ANIM_ReturnIdle01; xAnimTableNewState(table, g_strz_bossanim[ANIM_ReturnIdle01], 0x20, 0, 1, NULL, NULL, 0, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); - ANIM_KarateStart; xAnimTableNewState(table, g_strz_bossanim[ANIM_KarateStart], 0x20, 0, 1, NULL, NULL, 0, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); - ANIM_KarateLoop; xAnimTableNewState(table, g_strz_bossanim[ANIM_KarateLoop], 0x10, 0, 1, NULL, NULL, 0, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); - ANIM_KarateEnd; xAnimTableNewState(table, g_strz_bossanim[ANIM_KarateEnd], 0x20, 0, 1, NULL, NULL, 0, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); diff --git a/src/SB/Game/zNPCTypeBossSandy.cpp b/src/SB/Game/zNPCTypeBossSandy.cpp index 423289e89..26952ec99 100644 --- a/src/SB/Game/zNPCTypeBossSandy.cpp +++ b/src/SB/Game/zNPCTypeBossSandy.cpp @@ -62,7 +62,7 @@ static U8 sPCWasBubbleBouncing; static F32 sRadiusOfRing; static F32 sElbowDropTimer; static F32 sChaseTimer; -static F32 sNumAttacks; +static S32 sNumAttacks; static F32 sDidClothesline; static F32 sElbowDropThreshold; static zNPCBSandy* sSandyPtr; @@ -145,8 +145,7 @@ void on_change_shockwave(const tweak_info& tweak) xAnimTable* ZNPC_AnimTable_BossSandy() { // clang-format off - S32 ourAnims[28] = { - Unknown, + S32 ourAnims[25] = { Idle01, Idle02, Taunt01, @@ -172,13 +171,12 @@ xAnimTable* ZNPC_AnimTable_BossSandy() NoHeadGetUp01, NoHeadShotUp01, NoHeadShock01, - NoHeadReplace01, - NoHeadHit01, }; // clang-format on - //Missing like 2 logic lines or something, too tired to figure it out - xAnimTable* table = xAnimTableNew("zNPCBSandy", NULL, 0); + xAnimTransition* tList; + xAnimTable* table; + table = xAnimTableNew("zNPCBSandy", NULL, 0); xAnimTableNewState(table, g_strz_bossanim[Unknown], 0x10, 0x40, 1.0f, NULL, NULL, 0.0f, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); @@ -229,7 +227,7 @@ xAnimTable* ZNPC_AnimTable_BossSandy() NPCC_BuildStandardAnimTran(table, g_strz_bossanim, ourAnims, 1, 0.2f); - xAnimTransition* tList = table->TransitionList; + tList = table->TransitionList; while (tList != NULL) { tList->BlendRecip = 3.3333333f; @@ -259,7 +257,6 @@ U32 HeadNotShocked(xAnimTransition*, xAnimSingle*, void*) return !(sSandyPtr->bossFlags & 0x100); } - xAnimTable* ZNPC_AnimTable_BossSandyHead() { xAnimTable* table; @@ -273,14 +270,14 @@ xAnimTable* ZNPC_AnimTable_BossSandyHead() xAnimTableNewState(table, "Shocked01", 0x10, 0, 1.0f, NULL, NULL, 0.0f, NULL, NULL, xAnimDefaultBeforeEnter, NULL, NULL); - xAnimTableNewTransition(table, "Idle01", "Carried01", HeadIsCarried, NULL, 0, 0, 0.0f, 0.0f, - 0, 0, 0.25f, NULL); - xAnimTableNewTransition(table, "Carried01", "Idle01", HeadNotCarried, NULL, 0, 0, 0.0f, - 0.0f, 0, 0, 0.25f, NULL); - xAnimTableNewTransition(table, "Idle01", "Shocked01", HeadIsShocked, NULL, 0, 0, 0.0f, 0.0f, - 0, 0, 0.25f, NULL); - xAnimTableNewTransition(table, "Shocked01", "Idle01", HeadNotShocked, NULL, 0, 0, 0.0f, - 0.0f, 0, 0, 0.25f, NULL); + xAnimTableNewTransition(table, "Idle01", "Carried01", HeadIsCarried, NULL, 0, 0, 0.0f, 0.0f, 0, + 0, 0.25f, NULL); + xAnimTableNewTransition(table, "Carried01", "Idle01", HeadNotCarried, NULL, 0, 0, 0.0f, 0.0f, 0, + 0, 0.25f, NULL); + xAnimTableNewTransition(table, "Idle01", "Shocked01", HeadIsShocked, NULL, 0, 0, 0.0f, 0.0f, 0, + 0, 0.25f, NULL); + xAnimTableNewTransition(table, "Shocked01", "Idle01", HeadNotShocked, NULL, 0, 0, 0.0f, 0.0f, 0, + 0, 0.25f, NULL); return table; } @@ -1471,6 +1468,48 @@ S32 zNPCGoalBossSandyNoHead::Process(en_trantype* trantype, F32 dt, void* updCtx return zNPCGoalCommon::Process(trantype, dt, updCtxt, xscn); } +S32 zNPCGoalBossSandyElbowDrop::Enter(F32 dt, void* updCtxt) +{ + zNPCBSandy* sandy = (zNPCBSandy*)psyche->clt_owner; + + timeInGoal = 0; + sandy->bossFlags &= 0xfffffffd; + sNumAttacks++; + + xVec3Init(&sandy->frame->vel, 0.0f, 0.0f, 0.0f); + + xSndPlay3D(xStrHash("B101_SC_drop"), 0.77f, 0.0f, 0x0, 0x0, sandy, 30.0f, SND_CAT_GAME, 0.65f); + xSndPlay3D(xStrHash("B101_SC_drop"), 0.77f, 0.0f, 0x0, 0x0, sandy, 30.0f, SND_CAT_GAME, 1.3f); + xSndPlay3D(xStrHash("B101_SC_hitring"), 0.77f, 0.0f, 0x0, 0x0, sandy, 30.0f, SND_CAT_GAME, + 2.25f); + elbowFlags = 0; + return zNPCGoalCommon::Enter(dt, updCtxt); +} + +// This function is certified not cool +S32 zNPCGoalBossSandyElbowDrop::Process(en_trantype* trantype, F32 dt, void* updCtxt, xScene* xscn) +{ + zNPCBSandy* sandy = (zNPCBSandy*)psyche->clt_owner; + xVec3 newAt; + + if (timeInGoal > 0.75f) + { + for (S32 i = 0; i < 13; i++) + { + sandy->boundFlags[i] |= 0x1; + } + } + + if (timeInGoal <= sandy->edropTurnMinTime) + { + if (sandy->shockwaveMaxRadius < timeInGoal) + { + } + } + + return xGoal::Process(trantype, dt, updCtxt, xscn); +} + void xBinaryCamera::add_tweaks(char const*) { } diff --git a/src/SB/Game/zNPCTypeBossSandy.h b/src/SB/Game/zNPCTypeBossSandy.h index cbd5280fb..2904b6647 100644 --- a/src/SB/Game/zNPCTypeBossSandy.h +++ b/src/SB/Game/zNPCTypeBossSandy.h @@ -24,7 +24,7 @@ struct zNPCBSandy : zNPCBoss xEnt** boundList; // 0x2B4 U32* boundFlags; F32* boundEmitTimer; - U32 bossFlags; + U32 bossFlags; // 0x2c0 xVec3 currDir; F32 currVel; S32 hitPoints; // 0x2D4 diff --git a/src/SB/Game/zNPCTypeCommon.h b/src/SB/Game/zNPCTypeCommon.h index 80233c0ce..5dcc3af55 100644 --- a/src/SB/Game/zNPCTypeCommon.h +++ b/src/SB/Game/zNPCTypeCommon.h @@ -705,6 +705,7 @@ U32 xSndIsPlaying(U32 assetID, U32 parid); void zNPCMsg_AreaNotify(zNPCCommon* sender, en_NPC_MSG_ID msgid, F32 rad, S32 filter, en_NPCTYPES toNPCType); +void zNPCMsg_SendMsg(NPCMsg, float, zNPCCommon*); void zNPCMsg_SendMsg(en_NPC_MSG_ID msgevent, zNPCCommon* npc_sendto); void zNPCMsg_SendMsg(NPCMsg* inmsg, zNPCCommon* npc_sendto); void zNPCMsg_SendMsg(NPCMsg* inmsg, F32 delay, zNPCCommon* npc_sendto); diff --git a/src/SB/Game/zNPCTypeKingJelly.cpp b/src/SB/Game/zNPCTypeKingJelly.cpp index 523fc762c..2eb1ea54d 100644 --- a/src/SB/Game/zNPCTypeKingJelly.cpp +++ b/src/SB/Game/zNPCTypeKingJelly.cpp @@ -12,7 +12,7 @@ #define ANIM_Unknown 0 // 0x0 #define ANIM_Idle01 1 // 0x04 -#define ANIM_Idle02 2 // 0x08 +#define ANIM_Idle02 2 // 0x08 #define ANIM_Idle03 3 // 0xC #define ANIM_Fidget01 4 // #define ANIM_Fidget02 5 @@ -1294,6 +1294,11 @@ void zNPCKingJelly::Setup() zNPCSubBoss::Setup(); } +void zNPCKingJelly::Reset() +{ + // u32 i +} + void zNPCKingJelly::Destroy() { decompose(); @@ -1314,6 +1319,38 @@ void zNPCKingJelly::BUpdate(xVec3* pos) zNPCCommon::BUpdate(pos); } +S32 zNPCKingJelly::SysEvent(xBase* from, xBase* to, U32 toEvent, const F32* toParam, + xBase* toParamWidget, S32* handled) +{ + U32 uVar1; + + if (toEvent == 0x1b9) + { + LAB_8014808c: + uVar1 = 1; + } + else + { + if (toEvent < 0x1b9) + { + if (toEvent == 0x1b5) + { + start_fight(); + goto LAB_8014808c; + } + } + else if (toEvent == 0x1d9) + { + xPsyche* psy = this->psy_instinct; + psy->GoalSet(0x4e474d37, 1); + goto LAB_8014808c; + } + handled = 0; + uVar1 = zNPCCommon::SysEvent(from, to, toEvent, toParam, toParamWidget, handled); + } + return uVar1; +} + void zNPCKingJelly::RenderExtra() { zNPCKingJelly::render_debug(); diff --git a/src/SB/Game/zNPCTypeKingJelly.h b/src/SB/Game/zNPCTypeKingJelly.h index 33690b305..a3136aa02 100644 --- a/src/SB/Game/zNPCTypeKingJelly.h +++ b/src/SB/Game/zNPCTypeKingJelly.h @@ -10,7 +10,6 @@ #include "zNPCTypeAmbient.h" #include "xCamera.h" - namespace auto_tweak { template @@ -172,10 +171,13 @@ struct zNPCKingJelly : zNPCSubBoss zNPCKingJelly(S32 myType); void Setup(); + void Reset(); void Destroy(); U32 AnimPick(S32 rawgoal, en_NPC_GOAL_SPOT gspot, xGoal* goal); void Init(xEntAsset*); void BUpdate(xVec3*); + S32 SysEvent(xBase* from, xBase* to, U32 toEvent, const F32* toParam, xBase* toParamWidget, + S32* handled); void RenderExtra(); void ParseINI(); void SelfSetup(); @@ -183,6 +185,7 @@ struct zNPCKingJelly : zNPCSubBoss void init_child(zNPCKingJelly::child_data&, zNPCCommon&, int); void disable_child(zNPCKingJelly::child_data&); void enable_child(zNPCKingJelly::child_data& child); + void start_fight(); void spawn_children(int, int); S32 max_strikes(); void load_model(); diff --git a/src/dolphin/src/si/SIBios.c b/src/dolphin/src/si/SIBios.c index 030b026e3..28fae2837 100644 --- a/src/dolphin/src/si/SIBios.c +++ b/src/dolphin/src/si/SIBios.c @@ -899,4 +899,4 @@ char* SIGetTypeString(u32 type) case SI_GC_STEERING: return "Steering"; } -} \ No newline at end of file +} From fac342fabcbc8aba9d5cab92c7876e5f9fc2f96e Mon Sep 17 00:00:00 2001 From: Colin Miller Date: Mon, 8 Sep 2025 22:22:22 -0400 Subject: [PATCH 07/13] build fix --- src/SB/Game/zNPCMessenger.h | 7 +------ src/SB/Game/zNPCTypeCommon.h | 2 ++ 2 files changed, 3 insertions(+), 6 deletions(-) diff --git a/src/SB/Game/zNPCMessenger.h b/src/SB/Game/zNPCMessenger.h index 101e96056..c35430124 100644 --- a/src/SB/Game/zNPCMessenger.h +++ b/src/SB/Game/zNPCMessenger.h @@ -30,12 +30,7 @@ void zNPCMsg_SceneReset(); void zNPCMsg_ScenePrepare(); void zNPCMsg_Startup(); void zNPCMsg_Shutdown(); -void zNPCMsg_AreaNotify(zNPCCommon* sender, en_NPC_MSG_ID msgid, F32 rad, S32 filter, - en_NPCTYPES toNPCType); -void zNPCMsg_AreaNotify(zNPCCommon* sender, en_NPC_MSG_ID msgid, F32 rad, S32 filter, - en_NPCTYPES* toNPCType); -void zNPCMsg_AreaNotify(zNPCCommon* sender, NPCMsg* msg, F32 rad, S32 filter, - en_NPCTYPES* toNPCType); + void zNPCMsg_Timestep(xScene* xscn, F32 dt); void NPCPS_MsgPoolReset(NPCPSData* npc); void NPCPS_CltPoolReset(NPCPSData* npc); diff --git a/src/SB/Game/zNPCTypeCommon.h b/src/SB/Game/zNPCTypeCommon.h index 5dcc3af55..df93d0b60 100644 --- a/src/SB/Game/zNPCTypeCommon.h +++ b/src/SB/Game/zNPCTypeCommon.h @@ -704,6 +704,8 @@ U32 xSndIsPlaying(U32 assetID, U32 parid); void zNPCMsg_AreaNotify(zNPCCommon* sender, en_NPC_MSG_ID msgid, F32 rad, S32 filter, en_NPCTYPES toNPCType); +void zNPCMsg_AreaNotify(zNPCCommon*, en_NPC_MSG_ID, F32, S32, en_NPCTYPES*); +void zNPCMsg_AreaNotify(zNPCCommon*, NPCMsg*, F32, S32, en_NPCTYPES*); void zNPCMsg_SendMsg(NPCMsg, float, zNPCCommon*); void zNPCMsg_SendMsg(en_NPC_MSG_ID msgevent, zNPCCommon* npc_sendto); From 80dc53e5f197b7566f2d1cc7a2c0ca1262cf4e14 Mon Sep 17 00:00:00 2001 From: Colin Miller Date: Sat, 13 Sep 2025 11:04:14 -0400 Subject: [PATCH 08/13] xFX work and misc --- src/SB/Core/x/xFX.cpp | 242 ++++++++++++++++++++++++++++++----- src/SB/Core/x/xFX.h | 27 ++++ src/SB/Game/zEntPlayer.cpp | 16 +++ src/SB/Game/zEntPlayer.h | 15 +++ src/SB/Game/zNPCTypeCommon.h | 2 +- 5 files changed, 268 insertions(+), 34 deletions(-) diff --git a/src/SB/Core/x/xFX.cpp b/src/SB/Core/x/xFX.cpp index 3a6e713e4..ebff65660 100644 --- a/src/SB/Core/x/xFX.cpp +++ b/src/SB/Core/x/xFX.cpp @@ -1,9 +1,11 @@ #include "xFX.h" +#include "xDebug.h" #include "xstransvc.h" #include "xScrFx.h" #include "iMath.h" +#include "zEntPickup.h" #include "zParEmitter.h" #include "zSurface.h" #include "zFX.h" @@ -29,6 +31,8 @@ static U32 num_fx_atomics = 0; static U32 xfx_initted = 0; +xFXStreak sStreakList[10]; + static void LightResetFrame(RpLight* light); void xFXInit() @@ -365,9 +369,14 @@ static RpAtomic* AtomicSetShininess(RpAtomic* atomic, void* data) return atomic; } -void AtomicSetEnvMap(RpAtomic*, void*) +static RpAtomic* AtomicSetEnvMap(RpAtomic* atomic, void* data) { - + RpMatFXAtomicEnableEffects(atomic); + if ((atomic->geometry) != 0) + { + RpGeometryForAllMaterials((atomic->geometry), MaterialSetEnvMap2, data); + } + return atomic; } RpAtomic* xFXAtomicEnvMapSetup(RpAtomic* atomic, U32 aid, F32 shininess) @@ -651,8 +660,10 @@ void xFXShineInit() { } -void xFXShineStart(const xVec3*, F32, F32, F32, F32, U32, const iColor_tag*, const iColor_tag*, F32, S32) +U32 xFXShineStart(const xVec3*, F32, F32, F32, F32, U32, const iColor_tag*, const iColor_tag*, F32, + S32) { + return 2; } void xFXShineUpdate(F32) @@ -663,11 +674,67 @@ void xFXShineRender() { } +static void RenderRotatedBillboard(xVec3* pos, _xFXAuraAngle* rot, U32 count, F32 width, F32 height, + iColor_tag tint, U32 flipUV) +{ +} + void xFXAuraRender() { + // TODO: Fix function + // Honestly the closest I can get this function. + // fogstate is in the dwarf but currently isn't used in the function. + + S32 fogstate; // r29+0x3C + _xFXAura* ap; // r17 + _xFXAuraAngle* auraAng; + + if (gAuraTex != NULL) + { + RwRenderStateSet(rwRENDERSTATETEXTURERASTER, (void*)gAuraTex->raster); + RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)0x1); + RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)0x5); + RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)0x2); + RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)0x1); + RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)0x0); + RwRenderStateGet(rwRENDERSTATEFOGTYPE, (void*)0x1); + RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)0x0); + + ap = sAura; + + for (S32 i = 0; i < 32; i++) + { + if (ap->frame == gFrameCount) + { + auraAng = &sAuraAngle[0]; + RenderRotatedBillboard(&ap->pos, auraAng, 1, 0, 0, ap->color, 0); + auraAng = &sAuraAngle[1]; + RenderRotatedBillboard(&ap->pos, auraAng, 1, 0, 0, ap->color, 1); + } + ap = (_xFXAura*)ap->dangle; + } + + RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)0x5); + RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)0x6); + RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)0x1); + RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)0x1); + RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)0x10); + + ap = sAura; + + for (S32 i = 0; i < 32; i++) + { + if (ap->frame == gFrameCount && ap->parent != 0) + { + zEntPickup_RenderOne((xEnt*)ap->parent); + } + ap = (_xFXAura*)ap->dangle; + } + } } -void xFXFireworksInit(const char* trailEmit, const char* emit1, const char* emit2, const char* mainSound, const char* launchSound) +void xFXFireworksInit(const char* trailEmit, const char* emit1, const char* emit2, + const char* mainSound, const char* launchSound) { sFireworkTrailEmit = zParEmitterFind(trailEmit); sFirework1Emit = zParEmitterFind(emit1); @@ -721,15 +788,14 @@ void xFXFireworksUpdate(F32 dt) if (sFireworkLaunchSoundID != 0) { xSndPlay3D(sFireworkLaunchSoundID, - 0.308f, // Volume - 0.0f, // Pitch - 0x80, // Priority - 0, // Flags - &sFirework[i].pos, - 20.0f, // Radius - 5.0f, - SND_CAT_GAME, - 0.0f); // Delay + 0.308f, // Volume + 0.0f, // Pitch + 0x80, // Priority + 0, // Flags + &sFirework[i].pos, + 20.0f, // Radius + 5.0f, SND_CAT_GAME, + 0.0f); // Delay } } } @@ -769,7 +835,8 @@ void xFXFireworksUpdate(F32 dt) settings2.color_birth[1].set(127.0f * xurand() + 128.0f, 75.0f, 0.0f, 0); settings2.color_birth[2].set(127.0f * xurand() + 128.0f, 75.0f, 0.0f, 0); settings2.color_birth[3].set(255.0f, 0.0f, 1.0f, 0); - memcpy(settings2.color_death, &settings2.color_birth, sizeof(settings2.color_birth)); + memcpy(settings2.color_death, &settings2.color_birth, + sizeof(settings2.color_birth)); settings2.color_death[3].set(0.0f, 0.0f, 1.0f, 0); xParEmitterEmitCustom(emit, dt, &settings2); } @@ -785,21 +852,20 @@ void xFXFireworksUpdate(F32 dt) xVec3 diff; xVec3Sub(&diff, xEntGetPos(&globals.player.ent), &sFirework[i].pos); - zRumbleStartDistance(globals.currentActivePad, diff.x * diff.x + diff.z * diff.z, 48.0f, - eRumble_Medium, 0.35f); + zRumbleStartDistance(globals.currentActivePad, diff.x * diff.x + diff.z * diff.z, + 48.0f, eRumble_Medium, 0.35f); sFirework[i].pos.y = xEntGetPos(&globals.player.ent)->y; if (sFireworkSoundID != 0) { xSndPlay3D(sFireworkSoundID, - 0.77f, // Volume - 0.0f, // Pitch - 0x80, // Priority - 0, // Flags - &sFirework[i].pos, - 20.0f, // Radius - 5.0f, - SND_CAT_GAME, - 0.0f); // Delay + 0.77f, // Volume + 0.0f, // Pitch + 0x80, // Priority + 0, // Flags + &sFirework[i].pos, + 20.0f, // Radius + 5.0f, SND_CAT_GAME, + 0.0f); // Delay } } } @@ -808,7 +874,25 @@ void xFXFireworksUpdate(F32 dt) RpMaterial* MaterialSetBumpMap(RpMaterial* material, void* data) { - return NULL; + RwFrame* frame; + if (data == NULL) + { + return NULL; + } + else if (material->texture) + { + if (data) + { + frame = (RwFrame*)MainLight->object.object.parent; + RpMatFXMaterialSetEffects(material, rpMATFXEFFECTBUMPMAP); + RpMatFXMaterialSetupBumpMap(material, (RwTexture*)data, frame, 1.0f); + } + else + { + RpMatFXMaterialSetEffects(material, rpMATFXEFFECTNULL); + } + } + return material; } RpMaterial* MaterialSetEnvMap(RpMaterial* material, void* data) @@ -868,7 +952,8 @@ RpMaterial* MaterialSetEnvMap2(RpMaterial* material, void* data) return material; } -RpMaterial* MaterialSetBumpEnvMap(RpMaterial* material, RwTexture* envMap, F32 envCooef, RwTexture* bumpMap, F32 bumpCooef) +RpMaterial* MaterialSetBumpEnvMap(RpMaterial* material, RwTexture* envMap, F32 envCooef, + RwTexture* bumpMap, F32 bumpCooef) { if (envMap == NULL || bumpMap == NULL) { @@ -876,7 +961,7 @@ RpMaterial* MaterialSetBumpEnvMap(RpMaterial* material, RwTexture* envMap, F32 e } else { - RwFrame *frame; + RwFrame* frame; RpMatFXMaterialSetEffects(material, rpMATFXEFFECTBUMPENVMAP); if ((gFXSurfaceFlags & 0x10) != 0) { @@ -887,7 +972,8 @@ RpMaterial* MaterialSetBumpEnvMap(RpMaterial* material, RwTexture* envMap, F32 e frame = (RwFrame*)MainLight->object.object.parent; } RpMatFXMaterialSetupEnvMap(material, envMap, frame, TRUE, envCooef); - RpMatFXMaterialSetupBumpMap(material, bumpMap, (RwFrame*)MainLight->object.object.parent, bumpCooef); + RpMatFXMaterialSetupBumpMap(material, bumpMap, (RwFrame*)MainLight->object.object.parent, + bumpCooef); } return material; } @@ -909,22 +995,105 @@ void xFXanimUV2PSetTranslation(const xVec3*) { } -RpAtomic* xFXShinyRender(RpAtomic* atom) +RpAtomic* xFXShinyRender(RpAtomic* atomic) { - return NULL; + RwCullMode cmode; + + if (sTweaked == 0) + { + sEnvMap = xStrHash("default_env_map.RW3"); + sFresnelMap = xStrHash("gloss_edge"); + sTweaked = 1; + } + + RwRenderStateGet(rwRENDERSTATECULLMODE, NULL); + RwRenderStateSet(rwRENDERSTATECULLMODE, (void*)rwCULLMODECULLBACK); + iDrawSetFBMSK(-1); + iModelSetMaterialAlpha(atomic, rwCULLMODEFORCEENUMSIZEINT); + AtomicDisableMatFX(atomic); + (*gAtomicRenderCallBack)(atomic); + iDrawSetFBMSK(0); + iModelSetMaterialAlpha(atomic, 0); + gFXSurfaceFlags = 0x10; + xFXAtomicEnvMapSetup(atomic, sFresnelMap, 1.0f); + gFXSurfaceFlags = 0; + (*gAtomicRenderCallBack)(atomic); + iModelSetMaterialAlpha(atomic, 0xff); + AtomicDisableMatFX(atomic); + gFXSurfaceFlags = 0x10; + xFXAtomicEnvMapSetup(atomic, sEnvMap, 1.0f); + gFXSurfaceFlags = 0; + (*gAtomicRenderCallBack)(atomic); + RwRenderStateSet(rwRENDERSTATECULLMODE, (void*)0x8); // TODO: Fix Magic Number + + return atomic; } -RpAtomic* xFXBubbleRender(RpAtomic* atom) +RpAtomic* xFXBubbleRender(RpAtomic* atomic) { - return NULL; + RwCullMode cmode; + xFXBubbleParams* bp; + + bp = BFX + bfx_curr * 1; // Why multiply by 1? Probably needs rewritten differently + + RwRenderStateGet(rwRENDERSTATECULLMODE, NULL); + RwRenderStateSet(rwRENDERSTATECULLMODE, (void*)rwCULLMODECULLBACK); + iDrawSetFBMSK(bp->pass1_fbmsk); + iModelSetMaterialAlpha(atomic, bp->pass1_alpha); + + if (((char)bp->pass1)) + { + AtomicDisableMatFX(atomic); + (*gAtomicRenderCallBack)(atomic); + } + + iDrawSetFBMSK(0); + iModelSetMaterialAlpha(atomic, bp->pass2_alpha); + + if (((char)bp->pass2) != 0) + { + gFXSurfaceFlags = 0x10; + xFXAtomicEnvMapSetup(atomic, bp->fresnel_map, bp->fresnel_map_coeff); + gFXSurfaceFlags = 0; + (*gAtomicRenderCallBack)(atomic); + } + + iModelSetMaterialAlpha(atomic, bp->pass3_alpha); + + if (((char)bp->pass3) != 0) + { + AtomicDisableMatFX(atomic); + gFXSurfaceFlags = 0x10; + xFXAtomicEnvMapSetup(atomic, bp->env_map, bp->env_map_coeff); + gFXSurfaceFlags = 0; + (*gAtomicRenderCallBack)(atomic); + } + + RwRenderStateSet(rwRENDERSTATECULLMODE, (void*)0x8); + + return atomic; } void xFXRibbonRender() { + xFXRibbon* prev; // r19 + U32 i; // r18 + xFXRibbon* ribbon; // r17 + + RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)0x0); + RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)0x1); + RwRenderStateSet(rwRENDERSTATESHADEMODE, (void*)0x2); + RwRenderStateSet(rwRENDERSTATECULLMODE, (void*)0x1); + + ribbon = 0x0; } void xFXStreakInit() { + for (S32 i = 0; i < 10; i++) + { + memset(&sStreakList[i], 0, sizeof(xFXStreak)); + } } void xFXStreakRender() @@ -978,6 +1147,13 @@ void xFXRibbon::set_texture(U32) { } +void xFXRibbon::start_render() +{ + RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)cfg.blend_src); + RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)cfg.blend_dst); + RwRenderStateSet(rwRENDERSTATETEXTURERASTER, (void*)raster); +} + void xFXRibbon::insert(const xVec3&, const xVec3&, F32, F32, U32) { } diff --git a/src/SB/Core/x/xFX.h b/src/SB/Core/x/xFX.h index c681a9496..9871382dc 100644 --- a/src/SB/Core/x/xFX.h +++ b/src/SB/Core/x/xFX.h @@ -4,6 +4,8 @@ #include "xMath3.h" #include "containers.h" #include "iColor.h" +#include "iDraw.h" +#include "iModel.h" #include #include @@ -81,6 +83,30 @@ struct xFXRibbon void debug_update(F32); void insert(const xVec3&, const xVec3&, F32, F32, unsigned int); void insert(const xVec3&, F32, F32, F32, U32); + void start_render(); +}; + +class xFXStreakElem +{ + U32 flag; + xVec3 p[2]; + F32 a; +}; + +class xFXStreak +{ + U32 flags; + F32 frequency; + F32 alphaFadeRate; + F32 alphaStart; + F32 elapsed; + F32 lifetime; + U32 head; + iColor_tag color_a; + iColor_tag color_b; + RwTexture* texturePtr; + RwRaster* textureRasterPtr; + xFXStreakElem elem[50]; }; #define RING_COUNT 8 @@ -100,6 +126,7 @@ void xFXPreAllocMatFX(RpClump* clump); RpAtomic* xFXBubbleRender(RpAtomic* atomic); RpAtomic* xFXShinyRender(RpAtomic* atomic); +RpMaterial* MaterialSetEnvMap2(RpMaterial* material, void* data); void xFXanimUV2PSetTexture(RwTexture* texture); void xFXanimUVSetTranslation(const xVec3* trans); diff --git a/src/SB/Game/zEntPlayer.cpp b/src/SB/Game/zEntPlayer.cpp index 6a6333026..89a424358 100644 --- a/src/SB/Game/zEntPlayer.cpp +++ b/src/SB/Game/zEntPlayer.cpp @@ -79,6 +79,7 @@ static S32 sPlayerAttackInAir; #define MAX_DELAYED_SOUNDS 8 static zDelayedStreamSound sDelayedSound[MAX_DELAYED_SOUNDS]; static zPlayerSndTimer sPlayerStreamSndTimer[ePlayerStreamSnd_Total] = {}; +//static PlayerStreakInfo sStreakInfo[3][4] = {}; F32 startJump; F32 startDouble; @@ -3698,6 +3699,21 @@ void zEntPlayer_Load(xEnt* ent, xSerial* serial) return; } +static void zEntPlayer_StreakFX(xEnt* ent, F32) +{ + S32 i; // r19 + S32 p; // r5 + S32 cp; // r16 + + for (S32 i = 0; i < 6; i++) + { + for (S32 p = 0; p < 2; p++) + { + //sStreakInfo[i][p] = 0; + } + } +} + void zEntPlayer_PatrickLaunch(xEnt* patLauncher) { globals.player.carry.patLauncher = patLauncher; diff --git a/src/SB/Game/zEntPlayer.h b/src/SB/Game/zEntPlayer.h index 00ce06680..8c5e91dfa 100644 --- a/src/SB/Game/zEntPlayer.h +++ b/src/SB/Game/zEntPlayer.h @@ -6,6 +6,7 @@ #include "xAnim.h" #include "zEnt.h" #include "zLasso.h" +#include "xColor.h" enum zControlOwner { @@ -367,6 +368,20 @@ struct zPlayerLassoInfo xAnimState* zeroAnim; }; +class PlayerStreakInfo +{ + U32 activated; + U32 streakID; + xModelTag* tagA; + xModelTag* tagB; + F32 alphaStart; + S32 streakTaper; + iColor_tag colA; + iColor_tag colB; + xVec3 a; + xVec3 b; +}; + #define SHINY_MAX 99999 extern _CurrentPlayer gCurrentPlayer; diff --git a/src/SB/Game/zNPCTypeCommon.h b/src/SB/Game/zNPCTypeCommon.h index df93d0b60..b2ed0f2b3 100644 --- a/src/SB/Game/zNPCTypeCommon.h +++ b/src/SB/Game/zNPCTypeCommon.h @@ -707,7 +707,7 @@ void zNPCMsg_AreaNotify(zNPCCommon* sender, en_NPC_MSG_ID msgid, F32 rad, S32 fi void zNPCMsg_AreaNotify(zNPCCommon*, en_NPC_MSG_ID, F32, S32, en_NPCTYPES*); void zNPCMsg_AreaNotify(zNPCCommon*, NPCMsg*, F32, S32, en_NPCTYPES*); -void zNPCMsg_SendMsg(NPCMsg, float, zNPCCommon*); +void zNPCMsg_SendMsg(NPCMsg, F32, zNPCCommon*); void zNPCMsg_SendMsg(en_NPC_MSG_ID msgevent, zNPCCommon* npc_sendto); void zNPCMsg_SendMsg(NPCMsg* inmsg, zNPCCommon* npc_sendto); void zNPCMsg_SendMsg(NPCMsg* inmsg, F32 delay, zNPCCommon* npc_sendto); From 3fcc5ef63094323e7a1d956b02e005c74a44893f Mon Sep 17 00:00:00 2001 From: Colin Miller Date: Sun, 14 Sep 2025 23:44:31 -0400 Subject: [PATCH 09/13] Dutchman + misc --- config/GQPE78/config.yml | 3 +- dwarf/SB/Core/p2/iModel.cpp | 1516 +++++++++++++++++------------- dwarf/SB/Core/x/xParSys.cpp | 1324 +++++++++++++++----------- src/SB/Core/gc/iModel.cpp | 55 +- src/SB/Core/gc/iParMgr.h | 6 +- src/SB/Core/x/containers.h | 1 + src/SB/Core/x/xBehaveMgr.cpp | 40 +- src/SB/Core/x/xBehaviour.h | 1 + src/SB/Core/x/xFX.h | 1 + src/SB/Core/x/xModel.h | 2 +- src/SB/Core/x/xParEmitter.h | 1 + src/SB/Core/x/xParSys.cpp | 47 + src/SB/Core/x/xParSys.h | 13 + src/SB/Game/zNPCTypeDutchman.cpp | 340 ++++++- src/SB/Game/zNPCTypeDutchman.h | 34 +- 15 files changed, 2165 insertions(+), 1219 deletions(-) diff --git a/config/GQPE78/config.yml b/config/GQPE78/config.yml index 1846d3137..a3da22131 100644 --- a/config/GQPE78/config.yml +++ b/config/GQPE78/config.yml @@ -5,4 +5,5 @@ symbols: config/GQPE78/symbols.txt splits: config/GQPE78/splits.txt symbols_known: true fill_gaps: false -ldscript_template: config/GQPE78/ldscript.tpl \ No newline at end of file +ldscript_template: config/GQPE78/ldscript.tpl +write_asm: true diff --git a/dwarf/SB/Core/p2/iModel.cpp b/dwarf/SB/Core/p2/iModel.cpp index 40af56676..13531b5b2 100644 --- a/dwarf/SB/Core/p2/iModel.cpp +++ b/dwarf/SB/Core/p2/iModel.cpp @@ -6,127 +6,140 @@ char buffer[16]; // size: 0x10, address: 0x0 char buffer[16]; // size: 0x10, address: 0x0 static unsigned int gLastAtomicCount; // size: 0x4, address: 0x50F7F8 -static class RpAtomic * gLastAtomicList[256]; // size: 0x400, address: 0x532C30 -static class RpLight * sEmptyDirectionalLight[4]; // size: 0x10, address: 0x533030 -static class RpLight * sEmptyAmbientLight; // size: 0x4, address: 0x50F7FC +static class RpAtomic* gLastAtomicList[256]; // size: 0x400, address: 0x532C30 +static class RpLight* sEmptyDirectionalLight[4]; // size: 0x10, address: 0x533030 +static class RpLight* sEmptyAmbientLight; // size: 0x4, address: 0x50F7FC static class RwRGBA sMaterialColor[16]; // size: 0x40, address: 0x533040 -static class RwTexture * sMaterialTexture[16]; // size: 0x40, address: 0x533080 +static class RwTexture* sMaterialTexture[16]; // size: 0x40, address: 0x533080 static unsigned char sMaterialAlpha[16]; // size: 0x10, address: 0x5330C0 static unsigned int sMaterialIdx; // size: 0x4, address: 0x50F800 static unsigned int sMaterialFlags; // size: 0x4, address: 0x50F804 -static class RpAtomic * sLastMaterial; // size: 0x4, address: 0x50F808 -class RpMaterial * iModelMaterialMulCB(class RpMaterial *, void *); // size: 0x0, address: 0x1ACD30 -class RpMaterial * iModelSetMaterialTextureCB(class RpMaterial *, void *); // size: 0x0, address: 0x1AD060 -unsigned char * giAnimScratch; // size: 0x4, address: 0x50E80C +static class RpAtomic* sLastMaterial; // size: 0x4, address: 0x50F808 +class RpMaterial* iModelMaterialMulCB(class RpMaterial*, void*); // size: 0x0, address: 0x1ACD30 +class RpMaterial* iModelSetMaterialTextureCB(class RpMaterial*, + void*); // size: 0x0, address: 0x1AD060 +unsigned char* giAnimScratch; // size: 0x4, address: 0x50E80C unsigned int ourGlobals[4096]; // size: 0x4000, address: 0x5BB928 class zGlobals globals; // size: 0x2050, address: 0x52C8F0 signed int iModelHack_DisablePrelight; // size: 0x4, address: 0x50FFD0 -class RwFrame * GetChildFrameHierarchy(class RwFrame *, void *); // size: 0x0, address: 0x1AF3C0 -class RpAtomic * NextAtomicCallback(class RpAtomic *, void *); // size: 0x0, address: 0x1AEEC0 -class RpAtomic * FindAtomicCallback(class RpAtomic *, void *); // size: 0x0, address: 0x1AF1D0 -class RwV3d { +class RwFrame* GetChildFrameHierarchy(class RwFrame*, void*); // size: 0x0, address: 0x1AF3C0 +class RpAtomic* NextAtomicCallback(class RpAtomic*, void*); // size: 0x0, address: 0x1AEEC0 +class RpAtomic* FindAtomicCallback(class RpAtomic*, void*); // size: 0x0, address: 0x1AF1D0 +class RwV3d +{ // total size: 0xC public: float x; // offset 0x0, size 0x4 float y; // offset 0x4, size 0x4 float z; // offset 0x8, size 0x4 }; -class RpMaterial { +class RpMaterial +{ // total size: 0x1C public: - class RwTexture * texture; // offset 0x0, size 0x4 + class RwTexture* texture; // offset 0x0, size 0x4 class RwRGBA color; // offset 0x4, size 0x4 - class RxPipeline * pipeline; // offset 0x8, size 0x4 + class RxPipeline* pipeline; // offset 0x8, size 0x4 class RwSurfaceProperties surfaceProps; // offset 0xC, size 0xC signed short refCount; // offset 0x18, size 0x2 signed short pad; // offset 0x1A, size 0x2 }; -class RpAtomic { +class RpAtomic +{ // total size: 0x70 public: class RwObjectHasFrame object; // offset 0x0, size 0x14 - class RwResEntry * repEntry; // offset 0x14, size 0x4 - class RpGeometry * geometry; // offset 0x18, size 0x4 + class RwResEntry* repEntry; // offset 0x14, size 0x4 + class RpGeometry* geometry; // offset 0x18, size 0x4 class RwSphere boundingSphere; // offset 0x1C, size 0x10 class RwSphere worldBoundingSphere; // offset 0x2C, size 0x10 - class RpClump * clump; // offset 0x3C, size 0x4 + class RpClump* clump; // offset 0x3C, size 0x4 class RwLLLink inClumpLink; // offset 0x40, size 0x8 - class RpAtomic * (* renderCallBack)(class RpAtomic *); // offset 0x48, size 0x4 + class RpAtomic* (*renderCallBack)(class RpAtomic*); // offset 0x48, size 0x4 class RpInterpolator interpolator; // offset 0x4C, size 0x14 unsigned short renderFrame; // offset 0x60, size 0x2 unsigned short pad; // offset 0x62, size 0x2 class RwLinkList llWorldSectorsInAtomic; // offset 0x64, size 0x8 - class RxPipeline * pipeline; // offset 0x6C, size 0x4 + class RxPipeline* pipeline; // offset 0x6C, size 0x4 }; -class xAnimState { +class xAnimState +{ // total size: 0x4C public: - class xAnimState * Next; // offset 0x0, size 0x4 - char * Name; // offset 0x4, size 0x4 + class xAnimState* Next; // offset 0x0, size 0x4 + char* Name; // offset 0x4, size 0x4 unsigned int ID; // offset 0x8, size 0x4 unsigned int Flags; // offset 0xC, size 0x4 unsigned int UserFlags; // offset 0x10, size 0x4 float Speed; // offset 0x14, size 0x4 - class xAnimFile * Data; // offset 0x18, size 0x4 - class xAnimEffect * Effects; // offset 0x1C, size 0x4 - class xAnimTransitionList * Default; // offset 0x20, size 0x4 - class xAnimTransitionList * List; // offset 0x24, size 0x4 - float * BoneBlend; // offset 0x28, size 0x4 - float * TimeSnap; // offset 0x2C, size 0x4 + class xAnimFile* Data; // offset 0x18, size 0x4 + class xAnimEffect* Effects; // offset 0x1C, size 0x4 + class xAnimTransitionList* Default; // offset 0x20, size 0x4 + class xAnimTransitionList* List; // offset 0x24, size 0x4 + float* BoneBlend; // offset 0x28, size 0x4 + float* TimeSnap; // offset 0x2C, size 0x4 float FadeRecip; // offset 0x30, size 0x4 - unsigned short * FadeOffset; // offset 0x34, size 0x4 - void * CallbackData; // offset 0x38, size 0x4 - class xAnimMultiFile * MultiFile; // offset 0x3C, size 0x4 - void (* BeforeEnter)(class xAnimPlay *, class xAnimState *); // offset 0x40, size 0x4 - void (* StateCallback)(class xAnimState *, class xAnimSingle *, void *); // offset 0x44, size 0x4 - void (* BeforeAnimMatrices)(class xAnimPlay *, class xQuat *, class xVec3 *, signed int); // offset 0x48, size 0x4 -}; -class RpHAnimHierarchy { + unsigned short* FadeOffset; // offset 0x34, size 0x4 + void* CallbackData; // offset 0x38, size 0x4 + class xAnimMultiFile* MultiFile; // offset 0x3C, size 0x4 + void (*BeforeEnter)(class xAnimPlay*, class xAnimState*); // offset 0x40, size 0x4 + void (*StateCallback)(class xAnimState*, class xAnimSingle*, void*); // offset 0x44, size 0x4 + void (*BeforeAnimMatrices)(class xAnimPlay*, class xQuat*, class xVec3*, + signed int); // offset 0x48, size 0x4 +}; +class RpHAnimHierarchy +{ // total size: 0x24 public: signed int flags; // offset 0x0, size 0x4 signed int numNodes; // offset 0x4, size 0x4 - class RwMatrixTag * pMatrixArray; // offset 0x8, size 0x4 - void * pMatrixArrayUnaligned; // offset 0xC, size 0x4 - class RpHAnimNodeInfo * pNodeInfo; // offset 0x10, size 0x4 - class RwFrame * parentFrame; // offset 0x14, size 0x4 - class RpHAnimHierarchy * parentHierarchy; // offset 0x18, size 0x4 + class RwMatrixTag* pMatrixArray; // offset 0x8, size 0x4 + void* pMatrixArrayUnaligned; // offset 0xC, size 0x4 + class RpHAnimNodeInfo* pNodeInfo; // offset 0x10, size 0x4 + class RwFrame* parentFrame; // offset 0x14, size 0x4 + class RpHAnimHierarchy* parentHierarchy; // offset 0x18, size 0x4 signed int rootParentOffset; // offset 0x1C, size 0x4 - class RtAnimInterpolator * currentAnim; // offset 0x20, size 0x4 + class RtAnimInterpolator* currentAnim; // offset 0x20, size 0x4 }; -class RxHeap { +class RxHeap +{ // total size: 0x1C public: unsigned int superBlockSize; // offset 0x0, size 0x4 - class rxHeapSuperBlockDescriptor * head; // offset 0x4, size 0x4 - class rxHeapBlockHeader * headBlock; // offset 0x8, size 0x4 - class rxHeapFreeBlock * freeBlocks; // offset 0xC, size 0x4 + class rxHeapSuperBlockDescriptor* head; // offset 0x4, size 0x4 + class rxHeapBlockHeader* headBlock; // offset 0x8, size 0x4 + class rxHeapFreeBlock* freeBlocks; // offset 0xC, size 0x4 unsigned int entriesAlloced; // offset 0x10, size 0x4 unsigned int entriesUsed; // offset 0x14, size 0x4 signed int dirty; // offset 0x18, size 0x4 }; -class xBase { +class xBase +{ // total size: 0x10 public: unsigned int id; // offset 0x0, size 0x4 unsigned char baseType; // offset 0x4, size 0x1 unsigned char linkCount; // offset 0x5, size 0x1 unsigned short baseFlags; // offset 0x6, size 0x2 - class xLinkAsset * link; // offset 0x8, size 0x4 - signed int (* eventFunc)(class xBase *, class xBase *, unsigned int, float *, class xBase *); // offset 0xC, size 0x4 + class xLinkAsset* link; // offset 0x8, size 0x4 + signed int (*eventFunc)(class xBase*, class xBase*, unsigned int, float*, + class xBase*); // offset 0xC, size 0x4 }; -class RpSector { +class RpSector +{ // total size: 0x4 public: signed int type; // offset 0x0, size 0x4 }; -class RwTexCoords { +class RwTexCoords +{ // total size: 0x8 public: float u; // offset 0x0, size 0x4 float v; // offset 0x4, size 0x4 }; -class RwMatrixTag { +class RwMatrixTag +{ // total size: 0x40 public: class RwV3d right; // offset 0x0, size 0xC @@ -138,13 +151,15 @@ class RwMatrixTag { class RwV3d pos; // offset 0x30, size 0xC unsigned int pad3; // offset 0x3C, size 0x4 }; -class RwBBox { +class RwBBox +{ // total size: 0x18 public: class RwV3d sup; // offset 0x0, size 0xC class RwV3d inf; // offset 0xC, size 0xC }; -class RwRGBA { +class RwRGBA +{ // total size: 0x4 public: unsigned char red; // offset 0x0, size 0x1 @@ -152,29 +167,31 @@ class RwRGBA { unsigned char blue; // offset 0x2, size 0x1 unsigned char alpha; // offset 0x3, size 0x1 }; -class RpWorld { +class RpWorld +{ // total size: 0x70 public: class RwObject object; // offset 0x0, size 0x8 unsigned int flags; // offset 0x8, size 0x4 enum RpWorldRenderOrder renderOrder; // offset 0xC, size 0x4 class RpMaterialList matList; // offset 0x10, size 0xC - class RpSector * rootSector; // offset 0x1C, size 0x4 + class RpSector* rootSector; // offset 0x1C, size 0x4 signed int numTexCoordSets; // offset 0x20, size 0x4 signed int numClumpsInWorld; // offset 0x24, size 0x4 - class RwLLLink * currentClumpLink; // offset 0x28, size 0x4 + class RwLLLink* currentClumpLink; // offset 0x28, size 0x4 class RwLinkList clumpList; // offset 0x2C, size 0x8 class RwLinkList lightList; // offset 0x34, size 0x8 class RwLinkList directionalLightList; // offset 0x3C, size 0x8 class RwV3d worldOrigin; // offset 0x44, size 0xC class RwBBox boundingBox; // offset 0x50, size 0x18 - class RpWorldSector * (* renderCallBack)(class RpWorldSector *); // offset 0x68, size 0x4 - class RxPipeline * pipeline; // offset 0x6C, size 0x4 + class RpWorldSector* (*renderCallBack)(class RpWorldSector*); // offset 0x68, size 0x4 + class RxPipeline* pipeline; // offset 0x6C, size 0x4 }; -class xEnt : public xBase { +class xEnt : public xBase +{ // total size: 0xD0 public: - class xEntAsset * asset; // offset 0x10, size 0x4 + class xEntAsset* asset; // offset 0x10, size 0x4 unsigned short idx; // offset 0x14, size 0x2 unsigned short num_updates; // offset 0x16, size 0x2 unsigned char flags; // offset 0x18, size 0x1 @@ -189,59 +206,63 @@ class xEnt : public xBase { unsigned char collLev; // offset 0x21, size 0x1 unsigned char chkby; // offset 0x22, size 0x1 unsigned char penby; // offset 0x23, size 0x1 - class xModelInstance * model; // offset 0x24, size 0x4 - class xModelInstance * collModel; // offset 0x28, size 0x4 - class xModelInstance * camcollModel; // offset 0x2C, size 0x4 - class xLightKit * lightKit; // offset 0x30, size 0x4 - void (* update)(class xEnt *, class xScene *, float); // offset 0x34, size 0x4 - void (* endUpdate)(class xEnt *, class xScene *, float); // offset 0x38, size 0x4 - void (* bupdate)(class xEnt *, class xVec3 *); // offset 0x3C, size 0x4 - void (* move)(class xEnt *, class xScene *, float, class xEntFrame *); // offset 0x40, size 0x4 - void (* render)(class xEnt *); // offset 0x44, size 0x4 - class xEntFrame * frame; // offset 0x48, size 0x4 - class xEntCollis * collis; // offset 0x4C, size 0x4 + class xModelInstance* model; // offset 0x24, size 0x4 + class xModelInstance* collModel; // offset 0x28, size 0x4 + class xModelInstance* camcollModel; // offset 0x2C, size 0x4 + class xLightKit* lightKit; // offset 0x30, size 0x4 + void (*update)(class xEnt*, class xScene*, float); // offset 0x34, size 0x4 + void (*endUpdate)(class xEnt*, class xScene*, float); // offset 0x38, size 0x4 + void (*bupdate)(class xEnt*, class xVec3*); // offset 0x3C, size 0x4 + void (*move)(class xEnt*, class xScene*, float, class xEntFrame*); // offset 0x40, size 0x4 + void (*render)(class xEnt*); // offset 0x44, size 0x4 + class xEntFrame* frame; // offset 0x48, size 0x4 + class xEntCollis* collis; // offset 0x4C, size 0x4 class xGridBound gridb; // offset 0x50, size 0x14 class xBound bound; // offset 0x64, size 0x4C - void (* transl)(class xEnt *, class xVec3 *, class xMat4x3 *); // offset 0xB0, size 0x4 - class xFFX * ffx; // offset 0xB4, size 0x4 - class xEnt * driver; // offset 0xB8, size 0x4 + void (*transl)(class xEnt*, class xVec3*, class xMat4x3*); // offset 0xB0, size 0x4 + class xFFX* ffx; // offset 0xB4, size 0x4 + class xEnt* driver; // offset 0xB8, size 0x4 signed int driveMode; // offset 0xBC, size 0x4 - class xShadowSimpleCache * simpShadow; // offset 0xC0, size 0x4 - class xEntShadow * entShadow; // offset 0xC4, size 0x4 - class anim_coll_data * anim_coll; // offset 0xC8, size 0x4 - void * user_data; // offset 0xCC, size 0x4 + class xShadowSimpleCache* simpShadow; // offset 0xC0, size 0x4 + class xEntShadow* entShadow; // offset 0xC4, size 0x4 + class anim_coll_data* anim_coll; // offset 0xC8, size 0x4 + void* user_data; // offset 0xCC, size 0x4 }; -class RxPipeline { +class RxPipeline +{ // total size: 0x34 public: signed int locked; // offset 0x0, size 0x4 unsigned int numNodes; // offset 0x4, size 0x4 - class RxPipelineNode * nodes; // offset 0x8, size 0x4 + class RxPipelineNode* nodes; // offset 0x8, size 0x4 unsigned int packetNumClusterSlots; // offset 0xC, size 0x4 enum rxEmbeddedPacketState embeddedPacketState; // offset 0x10, size 0x4 - class RxPacket * embeddedPacket; // offset 0x14, size 0x4 + class RxPacket* embeddedPacket; // offset 0x14, size 0x4 unsigned int numInputRequirements; // offset 0x18, size 0x4 - class RxPipelineRequiresCluster * inputRequirements; // offset 0x1C, size 0x4 - void * superBlock; // offset 0x20, size 0x4 + class RxPipelineRequiresCluster* inputRequirements; // offset 0x1C, size 0x4 + void* superBlock; // offset 0x20, size 0x4 unsigned int superBlockSize; // offset 0x24, size 0x4 unsigned int entryPoint; // offset 0x28, size 0x4 unsigned int pluginId; // offset 0x2C, size 0x4 unsigned int pluginData; // offset 0x30, size 0x4 }; -class xCollis { +class xCollis +{ // total size: 0x50 public: unsigned int flags; // offset 0x0, size 0x4 unsigned int oid; // offset 0x4, size 0x4 - void * optr; // offset 0x8, size 0x4 - class xModelInstance * mptr; // offset 0xC, size 0x4 + void* optr; // offset 0x8, size 0x4 + class xModelInstance* mptr; // offset 0xC, size 0x4 float dist; // offset 0x10, size 0x4 class xVec3 norm; // offset 0x14, size 0xC class xVec3 tohit; // offset 0x20, size 0xC class xVec3 depen; // offset 0x2C, size 0xC class xVec3 hdng; // offset 0x38, size 0xC - union { // inferred - class /* @class */ { + union + { // inferred + class /* @class */ + { // total size: 0xC public: float t; // offset 0x0, size 0x4 @@ -251,14 +272,15 @@ class xCollis { class tri_data tri; // offset 0x44, size 0xC }; }; -class xModelInstance { +class xModelInstance +{ // total size: 0x6C public: - class xModelInstance * Next; // offset 0x0, size 0x4 - class xModelInstance * Parent; // offset 0x4, size 0x4 - class xModelPool * Pool; // offset 0x8, size 0x4 - class xAnimPlay * Anim; // offset 0xC, size 0x4 - class RpAtomic * Data; // offset 0x10, size 0x4 + class xModelInstance* Next; // offset 0x0, size 0x4 + class xModelInstance* Parent; // offset 0x4, size 0x4 + class xModelPool* Pool; // offset 0x8, size 0x4 + class xAnimPlay* Anim; // offset 0xC, size 0x4 + class RpAtomic* Data; // offset 0x10, size 0x4 unsigned int PipeFlags; // offset 0x14, size 0x4 float RedMultiplier; // offset 0x18, size 0x4 float GreenMultiplier; // offset 0x1C, size 0x4 @@ -266,66 +288,71 @@ class xModelInstance { float Alpha; // offset 0x24, size 0x4 float FadeStart; // offset 0x28, size 0x4 float FadeEnd; // offset 0x2C, size 0x4 - class xSurface * Surf; // offset 0x30, size 0x4 - class xModelBucket * * Bucket; // offset 0x34, size 0x4 - class xModelInstance * BucketNext; // offset 0x38, size 0x4 - class xLightKit * LightKit; // offset 0x3C, size 0x4 - void * Object; // offset 0x40, size 0x4 + class xSurface* Surf; // offset 0x30, size 0x4 + class xModelBucket** Bucket; // offset 0x34, size 0x4 + class xModelInstance* BucketNext; // offset 0x38, size 0x4 + class xLightKit* LightKit; // offset 0x3C, size 0x4 + void* Object; // offset 0x40, size 0x4 unsigned short Flags; // offset 0x44, size 0x2 unsigned char BoneCount; // offset 0x46, size 0x1 unsigned char BoneIndex; // offset 0x47, size 0x1 - unsigned char * BoneRemap; // offset 0x48, size 0x4 - class RwMatrixTag * Mat; // offset 0x4C, size 0x4 + unsigned char* BoneRemap; // offset 0x48, size 0x4 + class RwMatrixTag* Mat; // offset 0x4C, size 0x4 class xVec3 Scale; // offset 0x50, size 0xC unsigned int modelID; // offset 0x5C, size 0x4 unsigned int shadowID; // offset 0x60, size 0x4 - class RpAtomic * shadowmapAtomic; // offset 0x64, size 0x4 - class /* @class */ { + class RpAtomic* shadowmapAtomic; // offset 0x64, size 0x4 + class /* @class */ + { // total size: 0x4 public: - class xVec3 * verts; // offset 0x0, size 0x4 + class xVec3* verts; // offset 0x0, size 0x4 } anim_coll; // offset 0x68, size 0x4 }; -class RxPipelineNode { +class RxPipelineNode +{ // total size: 0x28 public: - class RxNodeDefinition * nodeDef; // offset 0x0, size 0x4 + class RxNodeDefinition* nodeDef; // offset 0x0, size 0x4 unsigned int numOutputs; // offset 0x4, size 0x4 - unsigned int * outputs; // offset 0x8, size 0x4 - class RxPipelineCluster * * slotClusterRefs; // offset 0xC, size 0x4 - unsigned int * slotsContinue; // offset 0x10, size 0x4 - void * privateData; // offset 0x14, size 0x4 - unsigned int * inputToClusterSlot; // offset 0x18, size 0x4 - class RxPipelineNodeTopSortData * topSortData; // offset 0x1C, size 0x4 - void * initializationData; // offset 0x20, size 0x4 + unsigned int* outputs; // offset 0x8, size 0x4 + class RxPipelineCluster** slotClusterRefs; // offset 0xC, size 0x4 + unsigned int* slotsContinue; // offset 0x10, size 0x4 + void* privateData; // offset 0x14, size 0x4 + unsigned int* inputToClusterSlot; // offset 0x18, size 0x4 + class RxPipelineNodeTopSortData* topSortData; // offset 0x1C, size 0x4 + void* initializationData; // offset 0x20, size 0x4 unsigned int initializationDataSize; // offset 0x24, size 0x4 }; -class RtAnimAnimation { +class RtAnimAnimation +{ // total size: 0x18 public: - class RtAnimInterpolatorInfo * interpInfo; // offset 0x0, size 0x4 + class RtAnimInterpolatorInfo* interpInfo; // offset 0x0, size 0x4 signed int numFrames; // offset 0x4, size 0x4 signed int flags; // offset 0x8, size 0x4 float duration; // offset 0xC, size 0x4 - void * pFrames; // offset 0x10, size 0x4 - void * customData; // offset 0x14, size 0x4 + void* pFrames; // offset 0x10, size 0x4 + void* customData; // offset 0x14, size 0x4 }; -class xQuat { +class xQuat +{ // total size: 0x10 public: class xVec3 v; // offset 0x0, size 0xC float s; // offset 0xC, size 0x4 }; -class RwCamera { +class RwCamera +{ // total size: 0x190 public: class RwObjectHasFrame object; // offset 0x0, size 0x14 enum RwCameraProjection projectionType; // offset 0x14, size 0x4 - class RwCamera * (* beginUpdate)(class RwCamera *); // offset 0x18, size 0x4 - class RwCamera * (* endUpdate)(class RwCamera *); // offset 0x1C, size 0x4 + class RwCamera* (*beginUpdate)(class RwCamera*); // offset 0x18, size 0x4 + class RwCamera* (*endUpdate)(class RwCamera*); // offset 0x1C, size 0x4 class RwMatrixTag viewMatrix; // offset 0x20, size 0x40 - class RwRaster * frameBuffer; // offset 0x60, size 0x4 - class RwRaster * zBuffer; // offset 0x64, size 0x4 + class RwRaster* frameBuffer; // offset 0x60, size 0x4 + class RwRaster* zBuffer; // offset 0x64, size 0x4 class RwV2d viewWindow; // offset 0x68, size 0x8 class RwV2d recipViewWindow; // offset 0x70, size 0x8 class RwV2d viewOffset; // offset 0x78, size 0x8 @@ -338,7 +365,8 @@ class RwCamera { class RwBBox frustumBoundBox; // offset 0x10C, size 0x18 class RwV3d frustumCorners[8]; // offset 0x124, size 0x60 }; -class xScene { +class xScene +{ // total size: 0x70 public: unsigned int sceneID; // offset 0x0, size 0x4 @@ -358,28 +386,31 @@ class xScene { unsigned short num_stats_allocd; // offset 0x24, size 0x2 unsigned short num_dyns_allocd; // offset 0x26, size 0x2 unsigned short num_npcs_allocd; // offset 0x28, size 0x2 - class xEnt * * trigs; // offset 0x2C, size 0x4 - class xEnt * * stats; // offset 0x30, size 0x4 - class xEnt * * dyns; // offset 0x34, size 0x4 - class xEnt * * npcs; // offset 0x38, size 0x4 - class xEnt * * act_ents; // offset 0x3C, size 0x4 - class xEnt * * nact_ents; // offset 0x40, size 0x4 - class xEnv * env; // offset 0x44, size 0x4 + class xEnt** trigs; // offset 0x2C, size 0x4 + class xEnt** stats; // offset 0x30, size 0x4 + class xEnt** dyns; // offset 0x34, size 0x4 + class xEnt** npcs; // offset 0x38, size 0x4 + class xEnt** act_ents; // offset 0x3C, size 0x4 + class xEnt** nact_ents; // offset 0x40, size 0x4 + class xEnv* env; // offset 0x44, size 0x4 class xMemPool mempool; // offset 0x48, size 0x1C - class xBase * (* resolvID)(unsigned int); // offset 0x64, size 0x4 - char * (* base2Name)(class xBase *); // offset 0x68, size 0x4 - char * (* id2Name)(unsigned int); // offset 0x6C, size 0x4 + class xBase* (*resolvID)(unsigned int); // offset 0x64, size 0x4 + char* (*base2Name)(class xBase*); // offset 0x68, size 0x4 + char* (*id2Name)(unsigned int); // offset 0x6C, size 0x4 }; -class xAnimEffect { +class xAnimEffect +{ // total size: 0x14 public: - class xAnimEffect * Next; // offset 0x0, size 0x4 + class xAnimEffect* Next; // offset 0x0, size 0x4 unsigned int Flags; // offset 0x4, size 0x4 float StartTime; // offset 0x8, size 0x4 float EndTime; // offset 0xC, size 0x4 - unsigned int (* Callback)(unsigned int, class xAnimActiveEffect *, class xAnimSingle *, void *); // offset 0x10, size 0x4 + unsigned int (*Callback)(unsigned int, class xAnimActiveEffect*, class xAnimSingle*, + void*); // offset 0x10, size 0x4 }; -class RpMeshHeader { +class RpMeshHeader +{ // total size: 0x10 public: unsigned int flags; // offset 0x0, size 0x4 @@ -388,7 +419,8 @@ class RpMeshHeader { unsigned int totalIndicesInMesh; // offset 0x8, size 0x4 unsigned int firstMeshOffset; // offset 0xC, size 0x4 }; -class xEntFrame { +class xEntFrame +{ // total size: 0xF0 public: class xMat4x3 mat; // offset 0x0, size 0x40 @@ -402,31 +434,35 @@ class xEntFrame { class xVec3 vel; // offset 0xD4, size 0xC unsigned int mode; // offset 0xE0, size 0x4 }; -class xVec3 { +class xVec3 +{ // total size: 0xC public: float x; // offset 0x0, size 0x4 float y; // offset 0x4, size 0x4 float z; // offset 0x8, size 0x4 }; -class xClumpCollBSPTree { +class xClumpCollBSPTree +{ // total size: 0x10 public: unsigned int numBranchNodes; // offset 0x0, size 0x4 - class xClumpCollBSPBranchNode * branchNodes; // offset 0x4, size 0x4 + class xClumpCollBSPBranchNode* branchNodes; // offset 0x4, size 0x4 unsigned int numTriangles; // offset 0x8, size 0x4 - class xClumpCollBSPTriangle * triangles; // offset 0xC, size 0x4 + class xClumpCollBSPTriangle* triangles; // offset 0xC, size 0x4 }; -class RwResEntry { +class RwResEntry +{ // total size: 0x18 public: class RwLLLink link; // offset 0x0, size 0x8 signed int size; // offset 0x8, size 0x4 - void * owner; // offset 0xC, size 0x4 - class RwResEntry * * ownerRef; // offset 0x10, size 0x4 - void (* destroyNotify)(class RwResEntry *); // offset 0x14, size 0x4 + void* owner; // offset 0xC, size 0x4 + class RwResEntry** ownerRef; // offset 0x10, size 0x4 + void (*destroyNotify)(class RwResEntry*); // offset 0x14, size 0x4 }; -class xEntCollis { +class xEntCollis +{ // total size: 0x5B4 public: unsigned char chk; // offset 0x0, size 0x1 @@ -441,75 +477,84 @@ class xEntCollis { unsigned char stat_eidx; // offset 0x9, size 0x1 unsigned char idx; // offset 0xA, size 0x1 class xCollis colls[18]; // offset 0xC, size 0x5A0 - void (* post)(class xEnt *, class xScene *, float, class xEntCollis *); // offset 0x5AC, size 0x4 - unsigned int (* depenq)(class xEnt *, class xEnt *, class xScene *, float, class xCollis *); // offset 0x5B0, size 0x4 + void (*post)(class xEnt*, class xScene*, float, class xEntCollis*); // offset 0x5AC, size 0x4 + unsigned int (*depenq)(class xEnt*, class xEnt*, class xScene*, float, + class xCollis*); // offset 0x5B0, size 0x4 }; -class RxPipelineNodeTopSortData { +class RxPipelineNodeTopSortData +{ // total size: 0xC public: unsigned int numIns; // offset 0x0, size 0x4 unsigned int numInsVisited; // offset 0x4, size 0x4 - class rxReq * req; // offset 0x8, size 0x4 + class rxReq* req; // offset 0x8, size 0x4 }; -class RpSkin { +class RpSkin +{ // total size: 0x0 }; -class rxHeapBlockHeader { +class rxHeapBlockHeader +{ // total size: 0x20 public: - class rxHeapBlockHeader * prev; // offset 0x0, size 0x4 - class rxHeapBlockHeader * next; // offset 0x4, size 0x4 + class rxHeapBlockHeader* prev; // offset 0x0, size 0x4 + class rxHeapBlockHeader* next; // offset 0x4, size 0x4 unsigned int size; // offset 0x8, size 0x4 - class rxHeapFreeBlock * freeEntry; // offset 0xC, size 0x4 + class rxHeapFreeBlock* freeEntry; // offset 0xC, size 0x4 unsigned int pad[4]; // offset 0x10, size 0x10 }; -class RwStreamCustom { +class RwStreamCustom +{ // total size: 0x14 public: - signed int (* sfnclose)(void *); // offset 0x0, size 0x4 - unsigned int (* sfnread)(void *, void *, unsigned int); // offset 0x4, size 0x4 - signed int (* sfnwrite)(void *, void *, unsigned int); // offset 0x8, size 0x4 - signed int (* sfnskip)(void *, unsigned int); // offset 0xC, size 0x4 - void * data; // offset 0x10, size 0x4 + signed int (*sfnclose)(void*); // offset 0x0, size 0x4 + unsigned int (*sfnread)(void*, void*, unsigned int); // offset 0x4, size 0x4 + signed int (*sfnwrite)(void*, void*, unsigned int); // offset 0x8, size 0x4 + signed int (*sfnskip)(void*, unsigned int); // offset 0xC, size 0x4 + void* data; // offset 0x10, size 0x4 }; -class RpWorldSector { +class RpWorldSector +{ // total size: 0x90 public: signed int type; // offset 0x0, size 0x4 - class RpPolygon * polygons; // offset 0x4, size 0x4 - class RwV3d * vertices; // offset 0x8, size 0x4 - class RpVertexNormal * normals; // offset 0xC, size 0x4 - class RwTexCoords * texCoords[8]; // offset 0x10, size 0x20 - class RwRGBA * preLitLum; // offset 0x30, size 0x4 - class RwResEntry * repEntry; // offset 0x34, size 0x4 + class RpPolygon* polygons; // offset 0x4, size 0x4 + class RwV3d* vertices; // offset 0x8, size 0x4 + class RpVertexNormal* normals; // offset 0xC, size 0x4 + class RwTexCoords* texCoords[8]; // offset 0x10, size 0x20 + class RwRGBA* preLitLum; // offset 0x30, size 0x4 + class RwResEntry* repEntry; // offset 0x34, size 0x4 class RwLinkList collAtomicsInWorldSector; // offset 0x38, size 0x8 class RwLinkList noCollAtomicsInWorldSector; // offset 0x40, size 0x8 class RwLinkList lightsInWorldSector; // offset 0x48, size 0x8 class RwBBox boundingBox; // offset 0x50, size 0x18 class RwBBox tightBoundingBox; // offset 0x68, size 0x18 - class RpMeshHeader * mesh; // offset 0x80, size 0x4 - class RxPipeline * pipeline; // offset 0x84, size 0x4 + class RpMeshHeader* mesh; // offset 0x80, size 0x4 + class RxPipeline* pipeline; // offset 0x84, size 0x4 unsigned short matListWindowBase; // offset 0x88, size 0x2 unsigned short numVertices; // offset 0x8A, size 0x2 unsigned short numPolygons; // offset 0x8C, size 0x2 unsigned short pad; // offset 0x8E, size 0x2 }; -class /* @class */ { +class /* @class */ +{ // total size: 0xC public: float t; // offset 0x0, size 0x4 float u; // offset 0x4, size 0x4 float v; // offset 0x8, size 0x4 }; -class RpMorphTarget { +class RpMorphTarget +{ // total size: 0x1C public: - class RpGeometry * parentGeom; // offset 0x0, size 0x4 + class RpGeometry* parentGeom; // offset 0x0, size 0x4 class RwSphere boundingSphere; // offset 0x4, size 0x10 - class RwV3d * verts; // offset 0x14, size 0x4 - class RwV3d * normals; // offset 0x18, size 0x4 + class RwV3d* verts; // offset 0x14, size 0x4 + class RwV3d* normals; // offset 0x18, size 0x4 }; -class RpGeometry { +class RpGeometry +{ // total size: 0x60 public: class RwObject object; // offset 0x0, size 0x8 @@ -521,30 +566,34 @@ class RpGeometry { signed int numMorphTargets; // offset 0x18, size 0x4 signed int numTexCoordSets; // offset 0x1C, size 0x4 class RpMaterialList matList; // offset 0x20, size 0xC - class RpTriangle * triangles; // offset 0x2C, size 0x4 - class RwRGBA * preLitLum; // offset 0x30, size 0x4 - class RwTexCoords * texCoords[8]; // offset 0x34, size 0x20 - class RpMeshHeader * mesh; // offset 0x54, size 0x4 - class RwResEntry * repEntry; // offset 0x58, size 0x4 - class RpMorphTarget * morphTarget; // offset 0x5C, size 0x4 -}; -class RtAnimInterpolatorInfo { + class RpTriangle* triangles; // offset 0x2C, size 0x4 + class RwRGBA* preLitLum; // offset 0x30, size 0x4 + class RwTexCoords* texCoords[8]; // offset 0x34, size 0x20 + class RpMeshHeader* mesh; // offset 0x54, size 0x4 + class RwResEntry* repEntry; // offset 0x58, size 0x4 + class RpMorphTarget* morphTarget; // offset 0x5C, size 0x4 +}; +class RtAnimInterpolatorInfo +{ // total size: 0x30 public: signed int typeID; // offset 0x0, size 0x4 signed int interpKeyFrameSize; // offset 0x4, size 0x4 signed int animKeyFrameSize; // offset 0x8, size 0x4 - void (* keyFrameApplyCB)(void *, void *); // offset 0xC, size 0x4 - void (* keyFrameBlendCB)(void *, void *, void *, float); // offset 0x10, size 0x4 - void (* keyFrameInterpolateCB)(void *, void *, void *, float, void *); // offset 0x14, size 0x4 - void (* keyFrameAddCB)(void *, void *, void *); // offset 0x18, size 0x4 - void (* keyFrameMulRecipCB)(void *, void *); // offset 0x1C, size 0x4 - class RtAnimAnimation * (* keyFrameStreamReadCB)(class RwStream *, class RtAnimAnimation *); // offset 0x20, size 0x4 - signed int (* keyFrameStreamWriteCB)(class RtAnimAnimation *, class RwStream *); // offset 0x24, size 0x4 - signed int (* keyFrameStreamGetSizeCB)(class RtAnimAnimation *); // offset 0x28, size 0x4 + void (*keyFrameApplyCB)(void*, void*); // offset 0xC, size 0x4 + void (*keyFrameBlendCB)(void*, void*, void*, float); // offset 0x10, size 0x4 + void (*keyFrameInterpolateCB)(void*, void*, void*, float, void*); // offset 0x14, size 0x4 + void (*keyFrameAddCB)(void*, void*, void*); // offset 0x18, size 0x4 + void (*keyFrameMulRecipCB)(void*, void*); // offset 0x1C, size 0x4 + class RtAnimAnimation* (*keyFrameStreamReadCB)(class RwStream*, + class RtAnimAnimation*); // offset 0x20, size 0x4 + signed int (*keyFrameStreamWriteCB)(class RtAnimAnimation*, + class RwStream*); // offset 0x24, size 0x4 + signed int (*keyFrameStreamGetSizeCB)(class RtAnimAnimation*); // offset 0x28, size 0x4 signed int customDataSize; // offset 0x2C, size 0x4 }; -class RpLight { +class RpLight +{ // total size: 0x40 public: class RwObjectHasFrame object; // offset 0x0, size 0x14 @@ -556,41 +605,46 @@ class RpLight { unsigned short lightFrame; // offset 0x3C, size 0x2 unsigned short pad; // offset 0x3E, size 0x2 }; -class xClumpCollBSPVertInfo { +class xClumpCollBSPVertInfo +{ // total size: 0x4 public: unsigned short atomIndex; // offset 0x0, size 0x2 unsigned short meshVertIndex; // offset 0x2, size 0x2 }; -class xAnimFile { +class xAnimFile +{ // total size: 0x20 public: - class xAnimFile * Next; // offset 0x0, size 0x4 - char * Name; // offset 0x4, size 0x4 + class xAnimFile* Next; // offset 0x0, size 0x4 + char* Name; // offset 0x4, size 0x4 unsigned int ID; // offset 0x8, size 0x4 unsigned int FileFlags; // offset 0xC, size 0x4 float Duration; // offset 0x10, size 0x4 float TimeOffset; // offset 0x14, size 0x4 unsigned short BoneCount; // offset 0x18, size 0x2 unsigned char NumAnims[2]; // offset 0x1A, size 0x2 - void * * RawData; // offset 0x1C, size 0x4 + void** RawData; // offset 0x1C, size 0x4 }; -class RxPipelineRequiresCluster { +class RxPipelineRequiresCluster +{ // total size: 0xC public: - class RxClusterDefinition * clusterDef; // offset 0x0, size 0x4 + class RxClusterDefinition* clusterDef; // offset 0x0, size 0x4 enum RxClusterValidityReq rqdOrOpt; // offset 0x4, size 0x4 unsigned int slotIndex; // offset 0x8, size 0x4 }; -class RpHAnimNodeInfo { +class RpHAnimNodeInfo +{ // total size: 0x10 public: signed int nodeID; // offset 0x0, size 0x4 signed int nodeIndex; // offset 0x4, size 0x4 signed int flags; // offset 0x8, size 0x4 - class RwFrame * pFrame; // offset 0xC, size 0x4 + class RwFrame* pFrame; // offset 0xC, size 0x4 }; -class xClumpCollBSPBranchNode { +class xClumpCollBSPBranchNode +{ // total size: 0x10 public: unsigned int leftInfo; // offset 0x0, size 0x4 @@ -598,7 +652,8 @@ class xClumpCollBSPBranchNode { float leftValue; // offset 0x8, size 0x4 float rightValue; // offset 0xC, size 0x4 }; -class _tagxPad { +class _tagxPad +{ // total size: 0x148 public: unsigned char value[22]; // offset 0x0, size 0x16 @@ -621,45 +676,54 @@ class _tagxPad { float down_tmr[22]; // offset 0xC0, size 0x58 class analog_data analog[2]; // offset 0x118, size 0x30 }; -class xModelTag { +class xModelTag +{ // total size: 0x20 public: class xVec3 v; // offset 0x0, size 0xC unsigned int matidx; // offset 0xC, size 0x4 float wt[4]; // offset 0x10, size 0x10 }; -class xClumpCollBSPTriangle { +class xClumpCollBSPTriangle +{ // total size: 0x8 public: - class /* @class */ { + class /* @class */ + { // total size: 0x4 public: - union { // inferred + union + { // inferred class xClumpCollBSPVertInfo i; // offset 0x0, size 0x4 - class RwV3d * p; // offset 0x0, size 0x4 + class RwV3d* p; // offset 0x0, size 0x4 }; } v; // offset 0x0, size 0x4 unsigned char flags; // offset 0x4, size 0x1 unsigned char platData; // offset 0x5, size 0x1 unsigned short matIndex; // offset 0x6, size 0x2 }; -class xModelPool { +class xModelPool +{ // total size: 0xC public: - class xModelPool * Next; // offset 0x0, size 0x4 + class xModelPool* Next; // offset 0x0, size 0x4 unsigned int NumMatrices; // offset 0x4, size 0x4 - class xModelInstance * List; // offset 0x8, size 0x4 + class xModelInstance* List; // offset 0x8, size 0x4 }; -class xFFX { +class xFFX +{ // total size: 0x0 }; -class xAnimTransition { +class xAnimTransition +{ // total size: 0x2C public: - class xAnimTransition * Next; // offset 0x0, size 0x4 - class xAnimState * Dest; // offset 0x4, size 0x4 - unsigned int (* Conditional)(class xAnimTransition *, class xAnimSingle *, void *); // offset 0x8, size 0x4 - unsigned int (* Callback)(class xAnimTransition *, class xAnimSingle *, void *); // offset 0xC, size 0x4 + class xAnimTransition* Next; // offset 0x0, size 0x4 + class xAnimState* Dest; // offset 0x4, size 0x4 + unsigned int (*Conditional)(class xAnimTransition*, class xAnimSingle*, + void*); // offset 0x8, size 0x4 + unsigned int (*Callback)(class xAnimTransition*, class xAnimSingle*, + void*); // offset 0xC, size 0x4 unsigned int Flags; // offset 0x10, size 0x4 unsigned int UserFlags; // offset 0x14, size 0x4 float SrcTime; // offset 0x18, size 0x4 @@ -667,15 +731,17 @@ class xAnimTransition { unsigned short Priority; // offset 0x20, size 0x2 unsigned short QueuePriority; // offset 0x22, size 0x2 float BlendRecip; // offset 0x24, size 0x4 - unsigned short * BlendOffset; // offset 0x28, size 0x4 + unsigned short* BlendOffset; // offset 0x28, size 0x4 }; -class xAnimTransitionList { +class xAnimTransitionList +{ // total size: 0x8 public: - class xAnimTransitionList * Next; // offset 0x0, size 0x4 - class xAnimTransition * T; // offset 0x4, size 0x4 + class xAnimTransitionList* Next; // offset 0x0, size 0x4 + class xAnimTransition* T; // offset 0x4, size 0x4 }; -class xQCData { +class xQCData +{ // total size: 0x20 public: signed char xmin; // offset 0x0, size 0x1 @@ -689,7 +755,8 @@ class xQCData { class xVec3 min; // offset 0x8, size 0xC class xVec3 max; // offset 0x14, size 0xC }; -class zLasso { +class zLasso +{ // total size: 0xFC public: unsigned int flags; // offset 0x0, size 0x4 @@ -716,20 +783,23 @@ class zLasso { unsigned char reindex[5]; // offset 0xC4, size 0x5 class xVec3 anchor; // offset 0xCC, size 0xC class xModelTag tag; // offset 0xD8, size 0x20 - class xModelInstance * model; // offset 0xF8, size 0x4 + class xModelInstance* model; // offset 0xF8, size 0x4 }; -class zPlatform { +class zPlatform +{ // total size: 0x0 }; -class RpUserDataArray { +class RpUserDataArray +{ // total size: 0x10 public: - char * name; // offset 0x0, size 0x4 + char* name; // offset 0x0, size 0x4 enum RpUserDataFormat format; // offset 0x4, size 0x4 signed int numElements; // offset 0x8, size 0x4 - void * data; // offset 0xC, size 0x4 + void* data; // offset 0xC, size 0x4 }; -class xEnvAsset : public xBaseAsset { +class xEnvAsset : public xBaseAsset +{ // total size: 0x44 public: unsigned int bspAssetID; // offset 0x8, size 0x4 @@ -748,38 +818,43 @@ class xEnvAsset : public xBaseAsset { unsigned int bspMapperFXID; // offset 0x3C, size 0x4 float loldHeight; // offset 0x40, size 0x4 }; -class _tagxRumble { +class _tagxRumble +{ // total size: 0x10 public: enum _tagRumbleType type; // offset 0x0, size 0x4 float seconds; // offset 0x4, size 0x4 - class _tagxRumble * next; // offset 0x8, size 0x4 + class _tagxRumble* next; // offset 0x8, size 0x4 signed short active; // offset 0xC, size 0x2 unsigned short fxflags; // offset 0xE, size 0x2 }; -class xAnimPlay { +class xAnimPlay +{ // total size: 0x20 public: - class xAnimPlay * Next; // offset 0x0, size 0x4 + class xAnimPlay* Next; // offset 0x0, size 0x4 unsigned short NumSingle; // offset 0x4, size 0x2 unsigned short BoneCount; // offset 0x6, size 0x2 - class xAnimSingle * Single; // offset 0x8, size 0x4 - void * Object; // offset 0xC, size 0x4 - class xAnimTable * Table; // offset 0x10, size 0x4 - class xMemPool * Pool; // offset 0x14, size 0x4 - class xModelInstance * ModelInst; // offset 0x18, size 0x4 - void (* BeforeAnimMatrices)(class xAnimPlay *, class xQuat *, class xVec3 *, signed int); // offset 0x1C, size 0x4 -}; -class zGlobals : public xGlobals { + class xAnimSingle* Single; // offset 0x8, size 0x4 + void* Object; // offset 0xC, size 0x4 + class xAnimTable* Table; // offset 0x10, size 0x4 + class xMemPool* Pool; // offset 0x14, size 0x4 + class xModelInstance* ModelInst; // offset 0x18, size 0x4 + void (*BeforeAnimMatrices)(class xAnimPlay*, class xQuat*, class xVec3*, + signed int); // offset 0x1C, size 0x4 +}; +class zGlobals : public xGlobals +{ // total size: 0x2050 public: class zPlayerGlobals player; // offset 0x700, size 0x1940 - class zAssetPickupTable * pickupTable; // offset 0x2040, size 0x4 - class zCutsceneMgr * cmgr; // offset 0x2044, size 0x4 - class zScene * sceneCur; // offset 0x2048, size 0x4 - class zScene * scenePreload; // offset 0x204C, size 0x4 + class zAssetPickupTable* pickupTable; // offset 0x2040, size 0x4 + class zCutsceneMgr* cmgr; // offset 0x2044, size 0x4 + class zScene* sceneCur; // offset 0x2048, size 0x4 + class zScene* scenePreload; // offset 0x204C, size 0x4 }; -class RwFrame { +class RwFrame +{ // total size: 0xB0 public: class RwObject object; // offset 0x0, size 0x8 @@ -787,11 +862,12 @@ class RwFrame { class RwMatrixTag modelling; // offset 0x10, size 0x40 class RwMatrixTag ltm; // offset 0x50, size 0x40 class RwLinkList objectList; // offset 0x90, size 0x8 - class RwFrame * child; // offset 0x98, size 0x4 - class RwFrame * next; // offset 0x9C, size 0x4 - class RwFrame * root; // offset 0xA0, size 0x4 + class RwFrame* child; // offset 0x98, size 0x4 + class RwFrame* next; // offset 0x9C, size 0x4 + class RwFrame* root; // offset 0xA0, size 0x4 }; -class xVec4 { +class xVec4 +{ // total size: 0x10 public: float x; // offset 0x0, size 0x4 @@ -799,7 +875,8 @@ class xVec4 { float z; // offset 0x8, size 0x4 float w; // offset 0xC, size 0x4 }; -class xShadowSimpleCache { +class xShadowSimpleCache +{ // total size: 0x98 public: unsigned short flags; // offset 0x0, size 0x2 @@ -808,7 +885,7 @@ class xShadowSimpleCache { unsigned int collPriority; // offset 0x4, size 0x4 class xVec3 pos; // offset 0x8, size 0xC class xVec3 at; // offset 0x14, size 0xC - class xEnt * castOnEnt; // offset 0x20, size 0x4 + class xEnt* castOnEnt; // offset 0x20, size 0x4 class xShadowSimplePoly poly; // offset 0x24, size 0x30 float envHeight; // offset 0x54, size 0x4 float shadowHeight; // offset 0x58, size 0x4 @@ -817,37 +894,42 @@ class xShadowSimpleCache { float dydz; // offset 0x64, size 0x4 class xVec3 corner[4]; // offset 0x68, size 0x30 }; -class RtAnimInterpolator { +class RtAnimInterpolator +{ // total size: 0x4C public: - class RtAnimAnimation * pCurrentAnim; // offset 0x0, size 0x4 + class RtAnimAnimation* pCurrentAnim; // offset 0x0, size 0x4 float currentTime; // offset 0x4, size 0x4 - void * pNextFrame; // offset 0x8, size 0x4 - class RtAnimInterpolator * (* pAnimCallBack)(class RtAnimInterpolator *, void *); // offset 0xC, size 0x4 - void * pAnimCallBackData; // offset 0x10, size 0x4 + void* pNextFrame; // offset 0x8, size 0x4 + class RtAnimInterpolator* (*pAnimCallBack)(class RtAnimInterpolator*, + void*); // offset 0xC, size 0x4 + void* pAnimCallBackData; // offset 0x10, size 0x4 float animCallBackTime; // offset 0x14, size 0x4 - class RtAnimInterpolator * (* pAnimLoopCallBack)(class RtAnimInterpolator *, void *); // offset 0x18, size 0x4 - void * pAnimLoopCallBackData; // offset 0x1C, size 0x4 + class RtAnimInterpolator* (*pAnimLoopCallBack)(class RtAnimInterpolator*, + void*); // offset 0x18, size 0x4 + void* pAnimLoopCallBackData; // offset 0x1C, size 0x4 signed int maxInterpKeyFrameSize; // offset 0x20, size 0x4 signed int currentInterpKeyFrameSize; // offset 0x24, size 0x4 signed int currentAnimKeyFrameSize; // offset 0x28, size 0x4 signed int numNodes; // offset 0x2C, size 0x4 signed int isSubInterpolator; // offset 0x30, size 0x4 signed int offsetInParent; // offset 0x34, size 0x4 - class RtAnimInterpolator * parentAnimation; // offset 0x38, size 0x4 - void (* keyFrameApplyCB)(void *, void *); // offset 0x3C, size 0x4 - void (* keyFrameBlendCB)(void *, void *, void *, float); // offset 0x40, size 0x4 - void (* keyFrameInterpolateCB)(void *, void *, void *, float, void *); // offset 0x44, size 0x4 - void (* keyFrameAddCB)(void *, void *, void *); // offset 0x48, size 0x4 -}; -class RwSurfaceProperties { + class RtAnimInterpolator* parentAnimation; // offset 0x38, size 0x4 + void (*keyFrameApplyCB)(void*, void*); // offset 0x3C, size 0x4 + void (*keyFrameBlendCB)(void*, void*, void*, float); // offset 0x40, size 0x4 + void (*keyFrameInterpolateCB)(void*, void*, void*, float, void*); // offset 0x44, size 0x4 + void (*keyFrameAddCB)(void*, void*, void*); // offset 0x48, size 0x4 +}; +class RwSurfaceProperties +{ // total size: 0xC public: float ambient; // offset 0x0, size 0x4 float specular; // offset 0x4, size 0x4 float diffuse; // offset 0x8, size 0x4 }; -class zGlobalSettings { +class zGlobalSettings +{ // total size: 0x150 public: unsigned short AnalogMin; // offset 0x0, size 0x2 @@ -937,7 +1019,8 @@ class zGlobalSettings { unsigned char PowerUp[2]; // offset 0x149, size 0x2 unsigned char InitialPowerUp[2]; // offset 0x14B, size 0x2 }; -class xLinkAsset { +class xLinkAsset +{ // total size: 0x20 public: unsigned short srcEvent; // offset 0x0, size 0x2 @@ -947,36 +1030,41 @@ class xLinkAsset { unsigned int paramWidgetAssetID; // offset 0x18, size 0x4 unsigned int chkAssetID; // offset 0x1C, size 0x4 }; -class rxHeapSuperBlockDescriptor { +class rxHeapSuperBlockDescriptor +{ // total size: 0xC public: - void * start; // offset 0x0, size 0x4 + void* start; // offset 0x0, size 0x4 unsigned int size; // offset 0x4, size 0x4 - class rxHeapSuperBlockDescriptor * next; // offset 0x8, size 0x4 + class rxHeapSuperBlockDescriptor* next; // offset 0x8, size 0x4 }; -class xEntShadow { +class xEntShadow +{ // total size: 0x28 public: class xVec3 pos; // offset 0x0, size 0xC class xVec3 vec; // offset 0xC, size 0xC - class RpAtomic * shadowModel; // offset 0x18, size 0x4 + class RpAtomic* shadowModel; // offset 0x18, size 0x4 float dst_cast; // offset 0x1C, size 0x4 float radius[2]; // offset 0x20, size 0x8 }; -class _zPortal : public xBase { +class _zPortal : public xBase +{ // total size: 0x14 public: - class xPortalAsset * passet; // offset 0x10, size 0x4 + class xPortalAsset* passet; // offset 0x10, size 0x4 }; -class xGroup : public xBase { +class xGroup : public xBase +{ // total size: 0x20 public: - class xGroupAsset * asset; // offset 0x10, size 0x4 - class xBase * * item; // offset 0x14, size 0x4 + class xGroupAsset* asset; // offset 0x10, size 0x4 + class xBase** item; // offset 0x14, size 0x4 unsigned int last_index; // offset 0x18, size 0x4 signed int flg_group; // offset 0x1C, size 0x4 }; -class RpClump { +class RpClump +{ // total size: 0x2C public: class RwObject object; // offset 0x0, size 0x8 @@ -984,29 +1072,33 @@ class RpClump { class RwLinkList lightList; // offset 0x10, size 0x8 class RwLinkList cameraList; // offset 0x18, size 0x8 class RwLLLink inWorldLink; // offset 0x20, size 0x8 - class RpClump * (* callback)(class RpClump *, void *); // offset 0x28, size 0x4 + class RpClump* (*callback)(class RpClump*, void*); // offset 0x28, size 0x4 }; -class zAssetPickupTable { +class zAssetPickupTable +{ // total size: 0x0 }; -class rxReq { +class rxReq +{ // total size: 0x0 }; -class xUpdateCullEnt { +class xUpdateCullEnt +{ // total size: 0x10 public: unsigned short index; // offset 0x0, size 0x2 signed short groupIndex; // offset 0x2, size 0x2 - unsigned int (* cb)(void *, void *); // offset 0x4, size 0x4 - void * cbdata; // offset 0x8, size 0x4 - class xUpdateCullEnt * nextInGroup; // offset 0xC, size 0x4 + unsigned int (*cb)(void*, void*); // offset 0x4, size 0x4 + void* cbdata; // offset 0x8, size 0x4 + class xUpdateCullEnt* nextInGroup; // offset 0xC, size 0x4 }; -class RwRaster { +class RwRaster +{ // total size: 0x34 public: - class RwRaster * parent; // offset 0x0, size 0x4 - unsigned char * cpPixels; // offset 0x4, size 0x4 - unsigned char * palette; // offset 0x8, size 0x4 + class RwRaster* parent; // offset 0x0, size 0x4 + unsigned char* cpPixels; // offset 0x4, size 0x4 + unsigned char* palette; // offset 0x8, size 0x4 signed int width; // offset 0xC, size 0x4 signed int height; // offset 0x10, size 0x4 signed int depth; // offset 0x14, size 0x4 @@ -1017,91 +1109,104 @@ class RwRaster { unsigned char cFlags; // offset 0x21, size 0x1 unsigned char privateFlags; // offset 0x22, size 0x1 unsigned char cFormat; // offset 0x23, size 0x1 - unsigned char * originalPixels; // offset 0x24, size 0x4 + unsigned char* originalPixels; // offset 0x24, size 0x4 signed int originalWidth; // offset 0x28, size 0x4 signed int originalHeight; // offset 0x2C, size 0x4 signed int originalStride; // offset 0x30, size 0x4 }; -class zCutsceneMgr { +class zCutsceneMgr +{ // total size: 0x0 }; -class zPlayerLassoInfo { +class zPlayerLassoInfo +{ // total size: 0x120 public: - class xEnt * target; // offset 0x0, size 0x4 + class xEnt* target; // offset 0x0, size 0x4 float dist; // offset 0x4, size 0x4 unsigned char destroy; // offset 0x8, size 0x1 unsigned char targetGuide; // offset 0x9, size 0x1 float lassoRot; // offset 0xC, size 0x4 - class xEnt * swingTarget; // offset 0x10, size 0x4 - class xEnt * releasedSwing; // offset 0x14, size 0x4 + class xEnt* swingTarget; // offset 0x10, size 0x4 + class xEnt* releasedSwing; // offset 0x14, size 0x4 float copterTime; // offset 0x18, size 0x4 signed int canCopter; // offset 0x1C, size 0x4 class zLasso lasso; // offset 0x20, size 0xFC - class xAnimState * zeroAnim; // offset 0x11C, size 0x4 + class xAnimState* zeroAnim; // offset 0x11C, size 0x4 }; -class anim_coll_data { +class anim_coll_data +{ // total size: 0x0 }; -class xGroupAsset : public xBaseAsset { +class xGroupAsset : public xBaseAsset +{ // total size: 0xC public: unsigned short itemCount; // offset 0x8, size 0x2 unsigned short groupFlags; // offset 0xA, size 0x2 }; -enum RxClusterValidityReq { +enum RxClusterValidityReq +{ rxCLREQ_DONTWANT = 0, rxCLREQ_REQUIRED = 1, rxCLREQ_OPTIONAL = 2, rxCLUSTERVALIDITYREQFORCEENUMSIZEINT = 2147483647, }; -class zScene : public xScene { +class zScene : public xScene +{ // total size: 0x2C8 public: - class _zPortal * pendingPortal; // offset 0x70, size 0x4 - union { // inferred + class _zPortal* pendingPortal; // offset 0x70, size 0x4 + union + { // inferred unsigned int num_ents; // offset 0x74, size 0x4 unsigned int num_base; // offset 0x74, size 0x4 }; - union { // inferred - class xBase * * base; // offset 0x78, size 0x4 - class zEnt * * ents; // offset 0x78, size 0x4 + union + { // inferred + class xBase** base; // offset 0x78, size 0x4 + class zEnt** ents; // offset 0x78, size 0x4 }; unsigned int num_update_base; // offset 0x7C, size 0x4 - class xBase * * update_base; // offset 0x80, size 0x4 + class xBase** update_base; // offset 0x80, size 0x4 unsigned int baseCount[72]; // offset 0x84, size 0x120 - class xBase * baseList[72]; // offset 0x1A4, size 0x120 - class _zEnv * zen; // offset 0x2C4, size 0x4 + class xBase* baseList[72]; // offset 0x1A4, size 0x120 + class _zEnv* zen; // offset 0x2C4, size 0x4 }; -class xSphere { +class xSphere +{ // total size: 0x10 public: class xVec3 center; // offset 0x0, size 0xC float r; // offset 0xC, size 0x4 }; -class RwLLLink { +class RwLLLink +{ // total size: 0x8 public: - class RwLLLink * next; // offset 0x0, size 0x4 - class RwLLLink * prev; // offset 0x4, size 0x4 + class RwLLLink* next; // offset 0x0, size 0x4 + class RwLLLink* prev; // offset 0x4, size 0x4 }; -class RwStreamUnion { +class RwStreamUnion +{ // total size: 0x14 public: - union { // inferred + union + { // inferred class RwStreamMemory memory; // offset 0x0, size 0xC class RwStreamFile file; // offset 0x0, size 0x4 class RwStreamCustom custom; // offset 0x0, size 0x14 }; }; -class zLedgeGrabParams { +class zLedgeGrabParams +{ // total size: 0x380 public: float animGrab; // offset 0x0, size 0x4 float zdist; // offset 0x4, size 0x4 class xVec3 tranTable[60]; // offset 0x8, size 0x2D0 signed int tranCount; // offset 0x2D8, size 0x4 - class xEnt * optr; // offset 0x2DC, size 0x4 + class xEnt* optr; // offset 0x2DC, size 0x4 class xMat4x3 omat; // offset 0x2E0, size 0x40 float y0det; // offset 0x320, size 0x4 float dydet; // offset 0x324, size 0x4 @@ -1119,49 +1224,58 @@ class zLedgeGrabParams { float startrot; // offset 0x36C, size 0x4 float endrot; // offset 0x370, size 0x4 }; -class xAnimMultiFile : public xAnimMultiFileBase { +class xAnimMultiFile : public xAnimMultiFileBase +{ // total size: 0xC public: class xAnimMultiFileEntry Files[1]; // offset 0x4, size 0x8 }; -class /* @class */ { +class /* @class */ +{ // total size: 0x4 public: - union { // inferred + union + { // inferred class xClumpCollBSPVertInfo i; // offset 0x0, size 0x4 - class RwV3d * p; // offset 0x0, size 0x4 + class RwV3d* p; // offset 0x0, size 0x4 }; }; -class xMat4x3 : public xMat3x3 { +class xMat4x3 : public xMat3x3 +{ // total size: 0x40 public: class xVec3 pos; // offset 0x30, size 0xC unsigned int pad3; // offset 0x3C, size 0x4 }; -class xVec2 { +class xVec2 +{ // total size: 0x8 public: float x; // offset 0x0, size 0x4 float y; // offset 0x4, size 0x4 }; -enum RxNodeDefEditable { +enum RxNodeDefEditable +{ rxNODEDEFCONST = 0, rxNODEDEFEDITABLE = 1, rxNODEDEFEDITABLEFORCEENUMSIZEINT = 2147483647, }; -enum RxClusterValid { +enum RxClusterValid +{ rxCLVALID_NOCHANGE = 0, rxCLVALID_VALID = 1, rxCLVALID_INVALID = 2, rxCLUSTERVALIDFORCEENUMSIZEINT = 2147483647, }; -enum _zPlayerWallJumpState { +enum _zPlayerWallJumpState +{ k_WALLJUMP_NOT = 0, k_WALLJUMP_LAUNCH = 1, k_WALLJUMP_FLIGHT = 2, k_WALLJUMP_LAND = 3, }; -enum RwStreamType { +enum RwStreamType +{ rwNASTREAM = 0, rwSTREAMFILE = 1, rwSTREAMFILENAME = 2, @@ -1169,7 +1283,8 @@ enum RwStreamType { rwSTREAMCUSTOM = 4, rwSTREAMTYPEFORCEENUMSIZEINT = 2147483647, }; -class xBaseAsset { +class xBaseAsset +{ // total size: 0x8 public: unsigned int id; // offset 0x0, size 0x4 @@ -1177,7 +1292,8 @@ class xBaseAsset { unsigned char linkCount; // offset 0x5, size 0x1 unsigned short baseFlags; // offset 0x6, size 0x2 }; -class RpVertexNormal { +class RpVertexNormal +{ // total size: 0x4 public: signed char x; // offset 0x0, size 0x1 @@ -1185,79 +1301,90 @@ class RpVertexNormal { signed char z; // offset 0x2, size 0x1 unsigned char pad; // offset 0x3, size 0x1 }; -class xSurface { +class xSurface +{ // total size: 0x0 }; -class xAnimTable { +class xAnimTable +{ // total size: 0x1C public: - class xAnimTable * Next; // offset 0x0, size 0x4 - char * Name; // offset 0x4, size 0x4 - class xAnimTransition * TransitionList; // offset 0x8, size 0x4 - class xAnimState * StateList; // offset 0xC, size 0x4 + class xAnimTable* Next; // offset 0x0, size 0x4 + char* Name; // offset 0x4, size 0x4 + class xAnimTransition* TransitionList; // offset 0x8, size 0x4 + class xAnimState* StateList; // offset 0xC, size 0x4 unsigned int AnimIndex; // offset 0x10, size 0x4 unsigned int MorphIndex; // offset 0x14, size 0x4 unsigned int UserFlags; // offset 0x18, size 0x4 }; -class rxHeapFreeBlock { +class rxHeapFreeBlock +{ // total size: 0x8 public: unsigned int size; // offset 0x0, size 0x4 - class rxHeapBlockHeader * ptr; // offset 0x4, size 0x4 + class rxHeapBlockHeader* ptr; // offset 0x4, size 0x4 }; -class xRot { +class xRot +{ // total size: 0x10 public: class xVec3 axis; // offset 0x0, size 0xC float angle; // offset 0xC, size 0x4 }; -class xModelTagWithNormal : public xModelTag { +class xModelTagWithNormal : public xModelTag +{ // total size: 0x2C public: class xVec3 normal; // offset 0x20, size 0xC }; -class xBound { +class xBound +{ // total size: 0x4C public: class xQCData qcd; // offset 0x0, size 0x20 unsigned char type; // offset 0x20, size 0x1 unsigned char pad[3]; // offset 0x21, size 0x3 - union { // inferred + union + { // inferred class xSphere sph; // offset 0x24, size 0x10 class xBBox box; // offset 0x24, size 0x24 class xCylinder cyl; // offset 0x24, size 0x14 }; - class xMat4x3 * mat; // offset 0x48, size 0x4 + class xMat4x3* mat; // offset 0x48, size 0x4 }; -class iEnv { +class iEnv +{ // total size: 0x30 public: - class RpWorld * world; // offset 0x0, size 0x4 - class RpWorld * collision; // offset 0x4, size 0x4 - class RpWorld * fx; // offset 0x8, size 0x4 - class RpWorld * camera; // offset 0xC, size 0x4 - class xJSPHeader * jsp; // offset 0x10, size 0x4 - class RpLight * light[2]; // offset 0x14, size 0x8 - class RwFrame * light_frame[2]; // offset 0x1C, size 0x8 + class RpWorld* world; // offset 0x0, size 0x4 + class RpWorld* collision; // offset 0x4, size 0x4 + class RpWorld* fx; // offset 0x8, size 0x4 + class RpWorld* camera; // offset 0xC, size 0x4 + class xJSPHeader* jsp; // offset 0x10, size 0x4 + class RpLight* light[2]; // offset 0x14, size 0x8 + class RwFrame* light_frame[2]; // offset 0x1C, size 0x8 signed int memlvl; // offset 0x24, size 0x4 }; -enum rxEmbeddedPacketState { +enum rxEmbeddedPacketState +{ rxPKST_PACKETLESS = 0, rxPKST_UNUSED = 1, rxPKST_INUSE = 2, rxPKST_PENDING = 3, rxEMBEDDEDPACKETSTATEFORCEENUMSIZEINT = 2147483647, }; -class xModelBucket { +class xModelBucket +{ // total size: 0x14 public: - class RpAtomic * Data; // offset 0x0, size 0x4 - class RpAtomic * OriginalData; // offset 0x4, size 0x4 - class xModelInstance * List; // offset 0x8, size 0x4 + class RpAtomic* Data; // offset 0x0, size 0x4 + class RpAtomic* OriginalData; // offset 0x4, size 0x4 + class xModelInstance* List; // offset 0x8, size 0x4 signed int ClipFlags; // offset 0xC, size 0x4 unsigned int PipeFlags; // offset 0x10, size 0x4 }; -enum _tagRumbleType { +enum _tagRumbleType +{ eRumble_Off = 0, eRumble_Hi = 1, eRumble_VeryLightHi = 2, @@ -1273,7 +1400,8 @@ enum _tagRumbleType { eRumble_Total = 12, eRumbleForceU32 = 2147483647, }; -class RpInterpolator { +class RpInterpolator +{ // total size: 0x14 public: signed int flags; // offset 0x0, size 0x4 @@ -1283,7 +1411,8 @@ class RpInterpolator { float recipTime; // offset 0xC, size 0x4 float position; // offset 0x10, size 0x4 }; -class RwFrustumPlane { +class RwFrustumPlane +{ // total size: 0x14 public: class RwPlane plane; // offset 0x0, size 0x10 @@ -1292,45 +1421,52 @@ class RwFrustumPlane { unsigned char closestZ; // offset 0x12, size 0x1 unsigned char pad; // offset 0x13, size 0x1 }; -enum _zPlayerType { +enum _zPlayerType +{ ePlayer_SB = 0, ePlayer_Patrick = 1, ePlayer_Sandy = 2, ePlayer_MAXTYPES = 3, }; -class xUpdateCullGroup { +class xUpdateCullGroup +{ // total size: 0xC public: unsigned int active; // offset 0x0, size 0x4 unsigned short startIndex; // offset 0x4, size 0x2 unsigned short endIndex; // offset 0x6, size 0x2 - class xGroup * groupObject; // offset 0x8, size 0x4 + class xGroup* groupObject; // offset 0x8, size 0x4 }; -class xLightKit { +class xLightKit +{ // total size: 0x10 public: unsigned int tagID; // offset 0x0, size 0x4 unsigned int groupID; // offset 0x4, size 0x4 unsigned int lightCount; // offset 0x8, size 0x4 - class xLightKitLight * lightList; // offset 0xC, size 0x4 + class xLightKitLight* lightList; // offset 0xC, size 0x4 }; -enum RwCameraProjection { +enum RwCameraProjection +{ rwNACAMERAPROJECTION = 0, rwPERSPECTIVE = 1, rwPARALLEL = 2, rwCAMERAPROJECTIONFORCEENUMSIZEINT = 2147483647, }; -class zEnt : public xEnt { +class zEnt : public xEnt +{ // total size: 0xD4 public: - class xAnimTable * atbl; // offset 0xD0, size 0x4 + class xAnimTable* atbl; // offset 0xD0, size 0x4 }; -enum RxClusterForcePresent { +enum RxClusterForcePresent +{ rxCLALLOWABSENT = 0, rxCLFORCEPRESENT = 1, rxCLUSTERFORCEPRESENTFORCEENUMSIZEINT = 2147483647, }; -class RwStream { +class RwStream +{ // total size: 0x24 public: enum RwStreamType type; // offset 0x0, size 0x4 @@ -1339,26 +1475,30 @@ class RwStream { class RwStreamUnion Type; // offset 0xC, size 0x14 signed int rwOwned; // offset 0x20, size 0x4 }; -class xCylinder { +class xCylinder +{ // total size: 0x14 public: class xVec3 center; // offset 0x0, size 0xC float r; // offset 0xC, size 0x4 float h; // offset 0x10, size 0x4 }; -class xJSPNodeInfo { +class xJSPNodeInfo +{ // total size: 0x8 public: signed int originalMatIndex; // offset 0x0, size 0x4 signed int nodeFlags; // offset 0x4, size 0x4 }; -class xBBox { +class xBBox +{ // total size: 0x24 public: class xVec3 center; // offset 0x0, size 0xC class xBox box; // offset 0xC, size 0x18 }; -class analog_data { +class analog_data +{ // total size: 0x18 public: class xVec2 offset; // offset 0x0, size 0x8 @@ -1366,54 +1506,60 @@ class analog_data { float mag; // offset 0x10, size 0x4 float ang; // offset 0x14, size 0x4 }; -class xBox { +class xBox +{ // total size: 0x18 public: class xVec3 upper; // offset 0x0, size 0xC class xVec3 lower; // offset 0xC, size 0xC }; -class RxClusterDefinition { +class RxClusterDefinition +{ // total size: 0x10 public: - char * name; // offset 0x0, size 0x4 + char* name; // offset 0x0, size 0x4 unsigned int defaultStride; // offset 0x4, size 0x4 unsigned int defaultAttributes; // offset 0x8, size 0x4 - char * attributeSet; // offset 0xC, size 0x4 + char* attributeSet; // offset 0xC, size 0x4 }; -class RpPolygon { +class RpPolygon +{ // total size: 0x8 public: unsigned short matIndex; // offset 0x0, size 0x2 unsigned short vertIndex[3]; // offset 0x2, size 0x6 }; -enum RwStreamAccessType { +enum RwStreamAccessType +{ rwNASTREAMACCESS = 0, rwSTREAMREAD = 1, rwSTREAMWRITE = 2, rwSTREAMAPPEND = 3, rwSTREAMACCESSTYPEFORCEENUMSIZEINT = 2147483647, }; -class RpMaterialList { +class RpMaterialList +{ // total size: 0xC public: - class RpMaterial * * materials; // offset 0x0, size 0x4 + class RpMaterial** materials; // offset 0x0, size 0x4 signed int numMaterials; // offset 0x4, size 0x4 signed int space; // offset 0x8, size 0x4 }; -class zPlayerGlobals { +class zPlayerGlobals +{ // total size: 0x1940 public: class zEnt ent; // offset 0x0, size 0xD4 class xEntShadow entShadow_embedded; // offset 0xD4, size 0x28 class xShadowSimpleCache simpShadow_embedded; // offset 0xFC, size 0x98 class zGlobalSettings g; // offset 0x194, size 0x150 - class zPlayerSettings * s; // offset 0x2E4, size 0x4 + class zPlayerSettings* s; // offset 0x2E4, size 0x4 class zPlayerSettings sb; // offset 0x2F0, size 0x460 class zPlayerSettings patrick; // offset 0x750, size 0x460 class zPlayerSettings sandy; // offset 0xBB0, size 0x460 - class xModelInstance * model_spongebob; // offset 0x1010, size 0x4 - class xModelInstance * model_patrick; // offset 0x1014, size 0x4 - class xModelInstance * model_sandy; // offset 0x1018, size 0x4 + class xModelInstance* model_spongebob; // offset 0x1010, size 0x4 + class xModelInstance* model_patrick; // offset 0x1014, size 0x4 + class xModelInstance* model_sandy; // offset 0x1018, size 0x4 unsigned int Visible; // offset 0x101C, size 0x4 unsigned int Health; // offset 0x1020, size 0x4 signed int Speed; // offset 0x1024, size 0x4 @@ -1435,7 +1581,7 @@ class zPlayerGlobals { float HotsauceTimer; // offset 0x1064, size 0x4 float LeanLerp; // offset 0x1068, size 0x4 float ScareTimer; // offset 0x106C, size 0x4 - class xBase * ScareSource; // offset 0x1070, size 0x4 + class xBase* ScareSource; // offset 0x1070, size 0x4 float CowerTimer; // offset 0x1074, size 0x4 float DamageTimer; // offset 0x1078, size 0x4 float SundaeTimer; // offset 0x107C, size 0x4 @@ -1447,7 +1593,7 @@ class zPlayerGlobals { float HeadbuttVel; // offset 0x1094, size 0x4 float HeadbuttTimer; // offset 0x1098, size 0x4 unsigned int SpecialReceived; // offset 0x109C, size 0x4 - class xEnt * MountChimney; // offset 0x10A0, size 0x4 + class xEnt* MountChimney; // offset 0x10A0, size 0x4 float MountChimOldY; // offset 0x10A4, size 0x4 unsigned int MaxHealth; // offset 0x10A8, size 0x4 unsigned int DoMeleeCheck; // offset 0x10AC, size 0x4 @@ -1468,24 +1614,24 @@ class zPlayerGlobals { float IdleMajorTimer; // offset 0x10E8, size 0x4 float IdleSitTimer; // offset 0x10EC, size 0x4 signed int Transparent; // offset 0x10F0, size 0x4 - class zEnt * FireTarget; // offset 0x10F4, size 0x4 + class zEnt* FireTarget; // offset 0x10F4, size 0x4 unsigned int ControlOff; // offset 0x10F8, size 0x4 unsigned int ControlOnEvent; // offset 0x10FC, size 0x4 unsigned int AutoMoveSpeed; // offset 0x1100, size 0x4 float AutoMoveDist; // offset 0x1104, size 0x4 class xVec3 AutoMoveTarget; // offset 0x1108, size 0xC - class xBase * AutoMoveObject; // offset 0x1114, size 0x4 - class zEnt * Diggable; // offset 0x1118, size 0x4 + class xBase* AutoMoveObject; // offset 0x1114, size 0x4 + class zEnt* Diggable; // offset 0x1118, size 0x4 float DigTimer; // offset 0x111C, size 0x4 class zPlayerCarryInfo carry; // offset 0x1120, size 0xE0 class zPlayerLassoInfo lassoInfo; // offset 0x1200, size 0x120 class xModelTag BubbleWandTag[2]; // offset 0x1320, size 0x40 - class xModelInstance * model_wand; // offset 0x1360, size 0x4 - class xEntBoulder * bubblebowl; // offset 0x1364, size 0x4 + class xModelInstance* model_wand; // offset 0x1360, size 0x4 + class xEntBoulder* bubblebowl; // offset 0x1364, size 0x4 float bbowlInitVel; // offset 0x1368, size 0x4 - class zEntHangable * HangFound; // offset 0x136C, size 0x4 - class zEntHangable * HangEnt; // offset 0x1370, size 0x4 - class zEntHangable * HangEntLast; // offset 0x1374, size 0x4 + class zEntHangable* HangFound; // offset 0x136C, size 0x4 + class zEntHangable* HangEnt; // offset 0x1370, size 0x4 + class zEntHangable* HangEntLast; // offset 0x1374, size 0x4 class xVec3 HangPivot; // offset 0x1378, size 0xC class xVec3 HangVel; // offset 0x1384, size 0xC float HangLength; // offset 0x1390, size 0x4 @@ -1500,7 +1646,7 @@ class zPlayerGlobals { signed int Jump_CanDouble; // offset 0x1438, size 0x4 signed int Jump_CanFloat; // offset 0x143C, size 0x4 signed int Jump_SpringboardStart; // offset 0x1440, size 0x4 - class zPlatform * Jump_Springboard; // offset 0x1444, size 0x4 + class zPlatform* Jump_Springboard; // offset 0x1444, size 0x4 signed int CanJump; // offset 0x1448, size 0x4 signed int CanBubbleSpin; // offset 0x144C, size 0x4 signed int CanBubbleBounce; // offset 0x1450, size 0x4 @@ -1525,7 +1671,7 @@ class zPlayerGlobals { unsigned int Inv_PatsSock_Total; // offset 0x1544, size 0x4 class xModelTag BubbleTag; // offset 0x1548, size 0x20 class xEntDrive drv; // offset 0x1568, size 0x7C - class xSurface * floor_surf; // offset 0x15E4, size 0x4 + class xSurface* floor_surf; // offset 0x15E4, size 0x4 class xVec3 floor_norm; // offset 0x15E8, size 0xC signed int slope; // offset 0x15F4, size 0x4 class xCollis earc_coll; // offset 0x15F8, size 0x50 @@ -1538,7 +1684,7 @@ class zPlayerGlobals { class zCheckPoint cp; // offset 0x16B8, size 0x14 unsigned int SlideTrackSliding; // offset 0x16CC, size 0x4 unsigned int SlideTrackCount; // offset 0x16D0, size 0x4 - class xEnt * SlideTrackEnt[111]; // offset 0x16D4, size 0x1BC + class xEnt* SlideTrackEnt[111]; // offset 0x16D4, size 0x1BC unsigned int SlideNotGroundedSinceSlide; // offset 0x1890, size 0x4 class xVec3 SlideTrackDir; // offset 0x1894, size 0xC class xVec3 SlideTrackVel; // offset 0x18A0, size 0xC @@ -1546,7 +1692,7 @@ class zPlayerGlobals { float SlideTrackLean; // offset 0x18B0, size 0x4 float SlideTrackLand; // offset 0x18B4, size 0x4 unsigned char sb_model_indices[14]; // offset 0x18B8, size 0xE - class xModelInstance * sb_models[14]; // offset 0x18C8, size 0x38 + class xModelInstance* sb_models[14]; // offset 0x18C8, size 0x38 unsigned int currentPlayer; // offset 0x1900, size 0x4 class xVec3 PredictRotate; // offset 0x1904, size 0xC class xVec3 PredictTranslate; // offset 0x1910, size 0xC @@ -1556,56 +1702,64 @@ class zPlayerGlobals { float KnockBackTimer; // offset 0x1930, size 0x4 float KnockIntoAirTimer; // offset 0x1934, size 0x4 }; -class zCheckPoint { +class zCheckPoint +{ // total size: 0x14 public: class xVec3 pos; // offset 0x0, size 0xC float rot; // offset 0xC, size 0x4 unsigned int initCamID; // offset 0x10, size 0x4 }; -class RwSphere { +class RwSphere +{ // total size: 0x10 public: class RwV3d center; // offset 0x0, size 0xC float radius; // offset 0xC, size 0x4 }; -class xAnimMultiFileEntry { +class xAnimMultiFileEntry +{ // total size: 0x8 public: unsigned int ID; // offset 0x0, size 0x4 - class xAnimFile * File; // offset 0x4, size 0x4 + class xAnimFile* File; // offset 0x4, size 0x4 }; -class xAnimActiveEffect { +class xAnimActiveEffect +{ // total size: 0x8 public: - class xAnimEffect * Effect; // offset 0x0, size 0x4 + class xAnimEffect* Effect; // offset 0x0, size 0x4 unsigned int Handle; // offset 0x4, size 0x4 }; -class xJSPHeader { +class xJSPHeader +{ // total size: 0x18 public: char idtag[4]; // offset 0x0, size 0x4 unsigned int version; // offset 0x4, size 0x4 unsigned int jspNodeCount; // offset 0x8, size 0x4 - class RpClump * clump; // offset 0xC, size 0x4 - class xClumpCollBSPTree * colltree; // offset 0x10, size 0x4 - class xJSPNodeInfo * jspNodeList; // offset 0x14, size 0x4 + class RpClump* clump; // offset 0xC, size 0x4 + class xClumpCollBSPTree* colltree; // offset 0x10, size 0x4 + class xJSPNodeInfo* jspNodeList; // offset 0x14, size 0x4 }; -class RwTexDictionary { +class RwTexDictionary +{ // total size: 0x18 public: class RwObject object; // offset 0x0, size 0x8 class RwLinkList texturesInDict; // offset 0x8, size 0x8 class RwLLLink lInInstance; // offset 0x10, size 0x8 }; -enum RpUserDataFormat { +enum RpUserDataFormat +{ rpNAUSERDATAFORMAT = 0, rpINTUSERDATA = 1, rpREALUSERDATA = 2, rpSTRINGUSERDATA = 3, rpUSERDATAFORCEENUMSIZEINT = 2147483647, }; -class xPortalAsset : public xBaseAsset { +class xPortalAsset : public xBaseAsset +{ // total size: 0x18 public: unsigned int assetCameraID; // offset 0x8, size 0x4 @@ -1613,27 +1767,29 @@ class xPortalAsset : public xBaseAsset { float ang; // offset 0x10, size 0x4 unsigned int sceneID; // offset 0x14, size 0x4 }; -class xGridBound { +class xGridBound +{ // total size: 0x14 public: - void * data; // offset 0x0, size 0x4 + void* data; // offset 0x0, size 0x4 unsigned short gx; // offset 0x4, size 0x2 unsigned short gz; // offset 0x6, size 0x2 unsigned char ingrid; // offset 0x8, size 0x1 unsigned char oversize; // offset 0x9, size 0x1 unsigned char deleted; // offset 0xA, size 0x1 unsigned char gpad; // offset 0xB, size 0x1 - class xGridBound * * head; // offset 0xC, size 0x4 - class xGridBound * next; // offset 0x10, size 0x4 + class xGridBound** head; // offset 0xC, size 0x4 + class xGridBound* next; // offset 0x10, size 0x4 }; -class zPlayerCarryInfo { +class zPlayerCarryInfo +{ // total size: 0xE0 public: - class xEnt * grabbed; // offset 0x0, size 0x4 + class xEnt* grabbed; // offset 0x0, size 0x4 unsigned int grabbedModelID; // offset 0x4, size 0x4 class xMat4x3 spin; // offset 0x10, size 0x40 - class xEnt * throwTarget; // offset 0x50, size 0x4 - class xEnt * flyingToTarget; // offset 0x54, size 0x4 + class xEnt* throwTarget; // offset 0x50, size 0x4 + class xEnt* flyingToTarget; // offset 0x54, size 0x4 float minDist; // offset 0x58, size 0x4 float maxDist; // offset 0x5C, size 0x4 float minHeight; // offset 0x60, size 0x4 @@ -1663,37 +1819,41 @@ class zPlayerCarryInfo { float fruitCeilingBounce; // offset 0xC8, size 0x4 float fruitWallBounce; // offset 0xCC, size 0x4 float fruitLifetime; // offset 0xD0, size 0x4 - class xEnt * patLauncher; // offset 0xD4, size 0x4 + class xEnt* patLauncher; // offset 0xD4, size 0x4 }; -class RxOutputSpec { +class RxOutputSpec +{ // total size: 0xC public: - char * name; // offset 0x0, size 0x4 - enum RxClusterValid * outputClusters; // offset 0x4, size 0x4 + char* name; // offset 0x0, size 0x4 + enum RxClusterValid* outputClusters; // offset 0x4, size 0x4 enum RxClusterValid allOtherClusters; // offset 0x8, size 0x4 }; -class xUpdateCullMgr { +class xUpdateCullMgr +{ // total size: 0x2C public: unsigned int entCount; // offset 0x0, size 0x4 unsigned int entActive; // offset 0x4, size 0x4 - void * * ent; // offset 0x8, size 0x4 - class xUpdateCullEnt * * mgr; // offset 0xC, size 0x4 + void** ent; // offset 0x8, size 0x4 + class xUpdateCullEnt** mgr; // offset 0xC, size 0x4 unsigned int mgrCount; // offset 0x10, size 0x4 unsigned int mgrCurr; // offset 0x14, size 0x4 - class xUpdateCullEnt * mgrList; // offset 0x18, size 0x4 + class xUpdateCullEnt* mgrList; // offset 0x18, size 0x4 unsigned int grpCount; // offset 0x1C, size 0x4 - class xUpdateCullGroup * grpList; // offset 0x20, size 0x4 - void (* activateCB)(void *); // offset 0x24, size 0x4 - void (* deactivateCB)(void *); // offset 0x28, size 0x4 + class xUpdateCullGroup* grpList; // offset 0x20, size 0x4 + void (*activateCB)(void*); // offset 0x24, size 0x4 + void (*deactivateCB)(void*); // offset 0x28, size 0x4 }; -class RwMemory { +class RwMemory +{ // total size: 0x8 public: - unsigned char * start; // offset 0x0, size 0x4 + unsigned char* start; // offset 0x0, size 0x4 unsigned int length; // offset 0x4, size 0x4 }; -class zPlayerSettings { +class zPlayerSettings +{ // total size: 0x460 public: enum _zPlayerType pcType; // offset 0x0, size 0x4 @@ -1720,26 +1880,28 @@ class zPlayerSettings { unsigned char talk_filter_size; // offset 0x459, size 0x1 unsigned char talk_filter[4]; // offset 0x45A, size 0x4 }; -class xAnimSingle { +class xAnimSingle +{ // total size: 0x40 public: unsigned int SingleFlags; // offset 0x0, size 0x4 - class xAnimState * State; // offset 0x4, size 0x4 + class xAnimState* State; // offset 0x4, size 0x4 float Time; // offset 0x8, size 0x4 float CurrentSpeed; // offset 0xC, size 0x4 float BilinearLerp[2]; // offset 0x10, size 0x8 - class xAnimEffect * Effect; // offset 0x18, size 0x4 + class xAnimEffect* Effect; // offset 0x18, size 0x4 unsigned int ActiveCount; // offset 0x1C, size 0x4 float LastTime; // offset 0x20, size 0x4 - class xAnimActiveEffect * ActiveList; // offset 0x24, size 0x4 - class xAnimPlay * Play; // offset 0x28, size 0x4 - class xAnimTransition * Sync; // offset 0x2C, size 0x4 - class xAnimTransition * Tran; // offset 0x30, size 0x4 - class xAnimSingle * Blend; // offset 0x34, size 0x4 + class xAnimActiveEffect* ActiveList; // offset 0x24, size 0x4 + class xAnimPlay* Play; // offset 0x28, size 0x4 + class xAnimTransition* Sync; // offset 0x2C, size 0x4 + class xAnimTransition* Tran; // offset 0x30, size 0x4 + class xAnimSingle* Blend; // offset 0x34, size 0x4 float BlendFactor; // offset 0x38, size 0x4 unsigned int pad; // offset 0x3C, size 0x4 }; -class xLightKitLight { +class xLightKitLight +{ // total size: 0x60 public: unsigned int type; // offset 0x0, size 0x4 @@ -1747,9 +1909,10 @@ class xLightKitLight { float matrix[16]; // offset 0x14, size 0x40 float radius; // offset 0x54, size 0x4 float angle; // offset 0x58, size 0x4 - class RpLight * platLight; // offset 0x5C, size 0x4 + class RpLight* platLight; // offset 0x5C, size 0x4 }; -class xMat3x3 { +class xMat3x3 +{ // total size: 0x30 public: class xVec3 right; // offset 0x0, size 0xC @@ -1759,19 +1922,20 @@ class xMat3x3 { class xVec3 at; // offset 0x20, size 0xC unsigned int pad2; // offset 0x2C, size 0x4 }; -class xCamera : public xBase { +class xCamera : public xBase +{ // total size: 0x330 public: - class RwCamera * lo_cam; // offset 0x10, size 0x4 + class RwCamera* lo_cam; // offset 0x10, size 0x4 class xMat4x3 mat; // offset 0x20, size 0x40 class xMat4x3 omat; // offset 0x60, size 0x40 class xMat3x3 mbasis; // offset 0xA0, size 0x30 class xBound bound; // offset 0xD0, size 0x4C - class xMat4x3 * tgt_mat; // offset 0x11C, size 0x4 - class xMat4x3 * tgt_omat; // offset 0x120, size 0x4 - class xBound * tgt_bound; // offset 0x124, size 0x4 + class xMat4x3* tgt_mat; // offset 0x11C, size 0x4 + class xMat4x3* tgt_omat; // offset 0x120, size 0x4 + class xBound* tgt_bound; // offset 0x124, size 0x4 class xVec3 focus; // offset 0x128, size 0xC - class xScene * sc; // offset 0x134, size 0x4 + class xScene* sc; // offset 0x134, size 0x4 class xVec3 tran_accum; // offset 0x138, size 0xC float fov; // offset 0x144, size 0x4 unsigned int flags; // offset 0x148, size 0x4 @@ -1839,35 +2003,40 @@ class xCamera : public xBase { float roll_csv; // offset 0x264, size 0x4 class xVec4 frustplane[12]; // offset 0x270, size 0xC0 }; -class RwStreamMemory { +class RwStreamMemory +{ // total size: 0xC public: unsigned int position; // offset 0x0, size 0x4 unsigned int nSize; // offset 0x4, size 0x4 - unsigned char * memBlock; // offset 0x8, size 0x4 + unsigned char* memBlock; // offset 0x8, size 0x4 }; -class RxClusterRef { +class RxClusterRef +{ // total size: 0xC public: - class RxClusterDefinition * clusterDef; // offset 0x0, size 0x4 + class RxClusterDefinition* clusterDef; // offset 0x0, size 0x4 enum RxClusterForcePresent forcePresent; // offset 0x4, size 0x4 unsigned int reserved; // offset 0x8, size 0x4 }; -class _zEnv : public xBase { +class _zEnv : public xBase +{ // total size: 0x14 public: - class xEnvAsset * easset; // offset 0x10, size 0x4 + class xEnvAsset* easset; // offset 0x10, size 0x4 }; -class RwObject { +class RwObject +{ // total size: 0x8 public: unsigned char type; // offset 0x0, size 0x1 unsigned char subType; // offset 0x1, size 0x1 unsigned char flags; // offset 0x2, size 0x1 unsigned char privateFlags; // offset 0x3, size 0x1 - void * parent; // offset 0x4, size 0x4 + void* parent; // offset 0x4, size 0x4 }; -class RwMatrixWeights { +class RwMatrixWeights +{ // total size: 0x10 public: float w0; // offset 0x0, size 0x4 @@ -1875,67 +2044,78 @@ class RwMatrixWeights { float w2; // offset 0x8, size 0x4 float w3; // offset 0xC, size 0x4 }; -class RxIoSpec { +class RxIoSpec +{ // total size: 0x14 public: unsigned int numClustersOfInterest; // offset 0x0, size 0x4 - class RxClusterRef * clustersOfInterest; // offset 0x4, size 0x4 - enum RxClusterValidityReq * inputRequirements; // offset 0x8, size 0x4 + class RxClusterRef* clustersOfInterest; // offset 0x4, size 0x4 + enum RxClusterValidityReq* inputRequirements; // offset 0x8, size 0x4 unsigned int numOutputs; // offset 0xC, size 0x4 - class RxOutputSpec * outputs; // offset 0x10, size 0x4 + class RxOutputSpec* outputs; // offset 0x10, size 0x4 }; -class xAnimMultiFileBase { +class xAnimMultiFileBase +{ // total size: 0x4 public: unsigned int Count; // offset 0x0, size 0x4 }; -class /* @class */ { +class /* @class */ +{ // total size: 0x4 public: - class xVec3 * verts; // offset 0x0, size 0x4 + class xVec3* verts; // offset 0x0, size 0x4 }; -class xMemPool { +class xMemPool +{ // total size: 0x1C public: - void * FreeList; // offset 0x0, size 0x4 + void* FreeList; // offset 0x0, size 0x4 unsigned short NextOffset; // offset 0x4, size 0x2 unsigned short Flags; // offset 0x6, size 0x2 - void * UsedList; // offset 0x8, size 0x4 - void (* InitCB)(class xMemPool *, void *); // offset 0xC, size 0x4 - void * Buffer; // offset 0x10, size 0x4 + void* UsedList; // offset 0x8, size 0x4 + void (*InitCB)(class xMemPool*, void*); // offset 0xC, size 0x4 + void* Buffer; // offset 0x10, size 0x4 unsigned short Size; // offset 0x14, size 0x2 unsigned short NumRealloc; // offset 0x16, size 0x2 unsigned int Total; // offset 0x18, size 0x4 }; -class RwTexture { +class RwTexture +{ // total size: 0x58 public: - class RwRaster * raster; // offset 0x0, size 0x4 - class RwTexDictionary * dict; // offset 0x4, size 0x4 + class RwRaster* raster; // offset 0x0, size 0x4 + class RwTexDictionary* dict; // offset 0x4, size 0x4 class RwLLLink lInDictionary; // offset 0x8, size 0x8 char name[32]; // offset 0x10, size 0x20 char mask[32]; // offset 0x30, size 0x20 unsigned int filterAddressing; // offset 0x50, size 0x4 signed int refCount; // offset 0x54, size 0x4 }; -class RxNodeMethods { +class RxNodeMethods +{ // total size: 0x1C public: - signed int (* nodeBody)(class RxPipelineNode *, class RxPipelineNodeParam *); // offset 0x0, size 0x4 - signed int (* nodeInit)(class RxNodeDefinition *); // offset 0x4, size 0x4 - void (* nodeTerm)(class RxNodeDefinition *); // offset 0x8, size 0x4 - signed int (* pipelineNodeInit)(class RxPipelineNode *); // offset 0xC, size 0x4 - void (* pipelineNodeTerm)(class RxPipelineNode *); // offset 0x10, size 0x4 - signed int (* pipelineNodeConfig)(class RxPipelineNode *, class RxPipeline *); // offset 0x14, size 0x4 - unsigned int (* configMsgHandler)(class RxPipelineNode *, unsigned int, unsigned int, void *); // offset 0x18, size 0x4 -}; -class RxPipelineCluster { + signed int (*nodeBody)(class RxPipelineNode*, + class RxPipelineNodeParam*); // offset 0x0, size 0x4 + signed int (*nodeInit)(class RxNodeDefinition*); // offset 0x4, size 0x4 + void (*nodeTerm)(class RxNodeDefinition*); // offset 0x8, size 0x4 + signed int (*pipelineNodeInit)(class RxPipelineNode*); // offset 0xC, size 0x4 + void (*pipelineNodeTerm)(class RxPipelineNode*); // offset 0x10, size 0x4 + signed int (*pipelineNodeConfig)(class RxPipelineNode*, + class RxPipeline*); // offset 0x14, size 0x4 + unsigned int (*configMsgHandler)(class RxPipelineNode*, unsigned int, unsigned int, + void*); // offset 0x18, size 0x4 +}; +class RxPipelineCluster +{ // total size: 0x8 public: - class RxClusterDefinition * clusterRef; // offset 0x0, size 0x4 + class RxClusterDefinition* clusterRef; // offset 0x0, size 0x4 unsigned int creationAttributes; // offset 0x4, size 0x4 }; -class xEntDrive { +class xEntDrive +{ // total size: 0x7C public: unsigned int flags; // offset 0x0, size 0x4 @@ -1945,9 +2125,9 @@ class xEntDrive { float tm; // offset 0x10, size 0x4 float tmr; // offset 0x14, size 0x4 float s; // offset 0x18, size 0x4 - class xEnt * odriver; // offset 0x1C, size 0x4 - class xEnt * driver; // offset 0x20, size 0x4 - class xEnt * driven; // offset 0x24, size 0x4 + class xEnt* odriver; // offset 0x1C, size 0x4 + class xEnt* driver; // offset 0x20, size 0x4 + class xEnt* driven; // offset 0x24, size 0x4 class xVec3 op; // offset 0x28, size 0xC class xVec3 p; // offset 0x34, size 0xC class xVec3 q; // offset 0x40, size 0xC @@ -1955,7 +2135,8 @@ class xEntDrive { class xVec3 dloc; // offset 0x50, size 0xC class tri_data tri; // offset 0x5C, size 0x20 }; -class xEntAsset : public xBaseAsset { +class xEntAsset : public xBaseAsset +{ // total size: 0x54 public: unsigned char flags; // offset 0x8, size 0x1 @@ -1975,7 +2156,8 @@ class xEntAsset : public xBaseAsset { unsigned int modelInfoID; // offset 0x4C, size 0x4 unsigned int animListID; // offset 0x50, size 0x4 }; -class iFogParams { +class iFogParams +{ // total size: 0x1C public: enum RwFogType type; // offset 0x0, size 0x4 @@ -1984,57 +2166,65 @@ class iFogParams { float density; // offset 0xC, size 0x4 class RwRGBA fogcolor; // offset 0x10, size 0x4 class RwRGBA bgcolor; // offset 0x14, size 0x4 - unsigned char * table; // offset 0x18, size 0x4 + unsigned char* table; // offset 0x18, size 0x4 }; -class RxNodeDefinition { +class RxNodeDefinition +{ // total size: 0x40 public: - char * name; // offset 0x0, size 0x4 + char* name; // offset 0x0, size 0x4 class RxNodeMethods nodeMethods; // offset 0x4, size 0x1C class RxIoSpec io; // offset 0x20, size 0x14 unsigned int pipelineNodePrivateDataSize; // offset 0x34, size 0x4 enum RxNodeDefEditable editable; // offset 0x38, size 0x4 signed int InputPipesCnt; // offset 0x3C, size 0x4 }; -class RwStreamFile { +class RwStreamFile +{ // total size: 0x4 public: - union { // inferred - void * fpFile; // offset 0x0, size 0x4 - void * constfpFile; // offset 0x0, size 0x4 + union + { // inferred + void* fpFile; // offset 0x0, size 0x4 + void* constfpFile; // offset 0x0, size 0x4 }; }; -class RwPlane { +class RwPlane +{ // total size: 0x10 public: class RwV3d normal; // offset 0x0, size 0xC float distance; // offset 0xC, size 0x4 }; -class RxCluster { +class RxCluster +{ // total size: 0x1C public: unsigned short flags; // offset 0x0, size 0x2 unsigned short stride; // offset 0x2, size 0x2 - void * data; // offset 0x4, size 0x4 - void * currentData; // offset 0x8, size 0x4 + void* data; // offset 0x4, size 0x4 + void* currentData; // offset 0x8, size 0x4 unsigned int numAlloced; // offset 0xC, size 0x4 unsigned int numUsed; // offset 0x10, size 0x4 - class RxPipelineCluster * clusterRef; // offset 0x14, size 0x4 + class RxPipelineCluster* clusterRef; // offset 0x14, size 0x4 unsigned int attributes; // offset 0x18, size 0x4 }; -class RpTriangle { +class RpTriangle +{ // total size: 0x8 public: unsigned short vertIndex[3]; // offset 0x0, size 0x6 signed short matIndex; // offset 0x6, size 0x2 }; -class RxPipelineNodeParam { +class RxPipelineNodeParam +{ // total size: 0x8 public: - void * dataParam; // offset 0x0, size 0x4 - class RxHeap * heap; // offset 0x4, size 0x4 + void* dataParam; // offset 0x0, size 0x4 + class RxHeap* heap; // offset 0x4, size 0x4 }; -class zJumpParam { +class zJumpParam +{ // total size: 0x10 public: float PeakHeight; // offset 0x0, size 0x4 @@ -2042,51 +2232,57 @@ class zJumpParam { float TimeHold; // offset 0x8, size 0x4 float ImpulseVel; // offset 0xC, size 0x4 }; -class RxPacket { +class RxPacket +{ // total size: 0x30 public: unsigned short flags; // offset 0x0, size 0x2 unsigned short numClusters; // offset 0x2, size 0x2 - class RxPipeline * pipeline; // offset 0x4, size 0x4 - unsigned int * inputToClusterSlot; // offset 0x8, size 0x4 - unsigned int * slotsContinue; // offset 0xC, size 0x4 - class RxPipelineCluster * * slotClusterRefs; // offset 0x10, size 0x4 + class RxPipeline* pipeline; // offset 0x4, size 0x4 + unsigned int* inputToClusterSlot; // offset 0x8, size 0x4 + unsigned int* slotsContinue; // offset 0xC, size 0x4 + class RxPipelineCluster** slotClusterRefs; // offset 0x10, size 0x4 class RxCluster clusters[1]; // offset 0x14, size 0x1C }; -class xEntBoulder { +class xEntBoulder +{ // total size: 0x0 }; -enum _tagPadState { +enum _tagPadState +{ ePad_Disabled = 0, ePad_DisabledError = 1, ePad_Enabled = 2, ePad_Missing = 3, ePad_Total = 4, }; -class zEntHangable { +class zEntHangable +{ // total size: 0x0 }; -enum RwFogType { +enum RwFogType +{ rwFOGTYPENAFOGTYPE = 0, rwFOGTYPELINEAR = 1, rwFOGTYPEEXPONENTIAL = 2, rwFOGTYPEEXPONENTIAL2 = 3, rwFOGTYPEFORCEENUMSIZEINT = 2147483647, }; -class xGlobals { +class xGlobals +{ // total size: 0x700 public: class xCamera camera; // offset 0x0, size 0x330 - class _tagxPad * pad0; // offset 0x330, size 0x4 - class _tagxPad * pad1; // offset 0x334, size 0x4 - class _tagxPad * pad2; // offset 0x338, size 0x4 - class _tagxPad * pad3; // offset 0x33C, size 0x4 + class _tagxPad* pad0; // offset 0x330, size 0x4 + class _tagxPad* pad1; // offset 0x334, size 0x4 + class _tagxPad* pad2; // offset 0x338, size 0x4 + class _tagxPad* pad3; // offset 0x33C, size 0x4 signed int profile; // offset 0x340, size 0x4 char profFunc[6][128]; // offset 0x344, size 0x300 - class xUpdateCullMgr * updateMgr; // offset 0x644, size 0x4 + class xUpdateCullMgr* updateMgr; // offset 0x644, size 0x4 signed int sceneFirst; // offset 0x648, size 0x4 char sceneStart[32]; // offset 0x64C, size 0x20 - class RpWorld * currWorld; // offset 0x66C, size 0x4 + class RpWorld* currWorld; // offset 0x66C, size 0x4 class iFogParams fog; // offset 0x670, size 0x1C class iFogParams fogA; // offset 0x68C, size 0x1C class iFogParams fogB; // offset 0x6A8, size 0x1C @@ -2103,7 +2299,8 @@ class xGlobals { unsigned char dontShowPadMessageDuringLoadingOrCutScene; // offset 0x6F0, size 0x1 unsigned char autoSaveFeature; // offset 0x6F1, size 0x1 }; -class RwRGBAReal { +class RwRGBAReal +{ // total size: 0x10 public: float red; // offset 0x0, size 0x4 @@ -2111,64 +2308,74 @@ class RwRGBAReal { float blue; // offset 0x8, size 0x4 float alpha; // offset 0xC, size 0x4 }; -class RwObjectHasFrame { +class RwObjectHasFrame +{ // total size: 0x14 public: class RwObject object; // offset 0x0, size 0x8 class RwLLLink lFrame; // offset 0x8, size 0x8 - class RwObjectHasFrame * (* sync)(class RwObjectHasFrame *); // offset 0x10, size 0x4 + class RwObjectHasFrame* (*sync)(class RwObjectHasFrame*); // offset 0x10, size 0x4 }; -class xEnv { +class xEnv +{ // total size: 0x50 public: - class iEnv * geom; // offset 0x0, size 0x4 + class iEnv* geom; // offset 0x0, size 0x4 class iEnv ienv; // offset 0x10, size 0x30 - class xLightKit * lightKit; // offset 0x40, size 0x4 + class xLightKit* lightKit; // offset 0x40, size 0x4 }; -class xShadowSimplePoly { +class xShadowSimplePoly +{ // total size: 0x30 public: class xVec3 vert[3]; // offset 0x0, size 0x24 class xVec3 norm; // offset 0x24, size 0xC }; -class RwLinkList { +class RwLinkList +{ // total size: 0x8 public: class RwLLLink link; // offset 0x0, size 0x8 }; -class tri_data : public tri_data { +class tri_data : public tri_data +{ // total size: 0x20 public: class xVec3 loc; // offset 0xC, size 0xC float yaw; // offset 0x18, size 0x4 - class xCollis * coll; // offset 0x1C, size 0x4 + class xCollis* coll; // offset 0x1C, size 0x4 }; -class tri_data { +class tri_data +{ // total size: 0xC public: unsigned int index; // offset 0x0, size 0x4 float r; // offset 0x4, size 0x4 float d; // offset 0x8, size 0x4 }; -class RwV2d { +class RwV2d +{ // total size: 0x8 public: float x; // offset 0x0, size 0x4 float y; // offset 0x4, size 0x4 }; -class _tagPadAnalog { +class _tagPadAnalog +{ // total size: 0x2 public: signed char x; // offset 0x0, size 0x1 signed char y; // offset 0x1, size 0x1 }; -enum RpWorldRenderOrder { +enum RpWorldRenderOrder +{ rpWORLDRENDERNARENDERORDER = 0, rpWORLDRENDERFRONT2BACK = 1, rpWORLDRENDERBACK2FRONT = 2, rpWORLDRENDERORDERFORCEENUMSIZEINT = 2147483647, }; -class _tagiPad { +class _tagiPad +{ // total size: 0x4 public: signed int port; // offset 0x0, size 0x4 @@ -2181,11 +2388,13 @@ class _tagiPad { Code range: 0x001ACCC0 -> 0x001ACD2C */ // Range: 0x1ACCC0 -> 0x1ACD2C -void iModelMaterialMul(class RpAtomic * model /* r16 */, float rm /* r29+0x30 */, float gm /* r29+0x30 */, float bm /* r29+0x30 */) { +void iModelMaterialMul(class RpAtomic* model /* r16 */, float rm /* r29+0x30 */, + float gm /* r29+0x30 */, float bm /* r29+0x30 */) +{ // Blocks /* anonymous block */ { // Range: 0x1ACCC0 -> 0x1ACD2C - class RpGeometry * geom; // r2 + class RpGeometry* geom; // r2 float cols[3]; // r29+0x20 } } @@ -2197,14 +2406,16 @@ void iModelMaterialMul(class RpAtomic * model /* r16 */, float rm /* r29+0x30 */ Code range: 0x001ACD30 -> 0x001ACFF8 */ // Range: 0x1ACD30 -> 0x1ACFF8 -static class RpMaterial * iModelMaterialMulCB(class RpMaterial * material /* r2 */, void * data /* r2 */) { +static class RpMaterial* iModelMaterialMulCB(class RpMaterial* material /* r2 */, + void* data /* r2 */) +{ // Blocks /* anonymous block */ { // Range: 0x1ACD30 -> 0x1ACFF8 - class RwRGBA * rw_col; // r2 + class RwRGBA* rw_col; // r2 class RwRGBA col; // r29+0xC float tmp; // r1 - float * mods; // r2 + float* mods; // r2 } } @@ -2215,11 +2426,12 @@ static class RpMaterial * iModelMaterialMulCB(class RpMaterial * material /* r2 Code range: 0x001AD000 -> 0x001AD054 */ // Range: 0x1AD000 -> 0x1AD054 -void iModelSetMaterialTexture(class RpAtomic * model /* r16 */, void * texture /* r2 */) { +void iModelSetMaterialTexture(class RpAtomic* model /* r16 */, void* texture /* r2 */) +{ // Blocks /* anonymous block */ { // Range: 0x1AD000 -> 0x1AD054 - class RpGeometry * geom; // r2 + class RpGeometry* geom; // r2 } } @@ -2230,7 +2442,9 @@ void iModelSetMaterialTexture(class RpAtomic * model /* r16 */, void * texture / Code range: 0x001AD060 -> 0x001AD0B0 */ // Range: 0x1AD060 -> 0x1AD0B0 -static class RpMaterial * iModelSetMaterialTextureCB(class RpMaterial * material /* r16 */, void * data /* r2 */) { +static class RpMaterial* iModelSetMaterialTextureCB(class RpMaterial* material /* r16 */, + void* data /* r2 */) +{ // Blocks /* anonymous block */ { // Range: 0x1AD060 -> 0x1AD0B0 @@ -2244,13 +2458,14 @@ static class RpMaterial * iModelSetMaterialTextureCB(class RpMaterial * material Code range: 0x001AD0B0 -> 0x001AD2DC */ // Range: 0x1AD0B0 -> 0x1AD2DC -void iModelResetMaterial(class RpAtomic * model /* r2 */) { +void iModelResetMaterial(class RpAtomic* model /* r2 */) +{ // Blocks /* anonymous block */ { // Range: 0x1AD0B0 -> 0x1AD2DC unsigned int i; // r20 - class RpGeometry * geom; // r21 - class RpMaterial * material; // r2 + class RpGeometry* geom; // r21 + class RpMaterial* material; // r2 class RwRGBA newColor; // r29+0xAC class RwRGBA newColor; // r29+0xA8 class RwRGBA newColor; // r29+0xA4 @@ -2264,14 +2479,15 @@ void iModelResetMaterial(class RpAtomic * model /* r2 */) { Code range: 0x001AD2E0 -> 0x001AD3C0 */ // Range: 0x1AD2E0 -> 0x1AD3C0 -void iModelSetMaterialAlpha(class RpAtomic * model /* r2 */, unsigned char alpha /* r2 */) { +void iModelSetMaterialAlpha(class RpAtomic* model /* r2 */, unsigned char alpha /* r2 */) +{ // Blocks /* anonymous block */ { // Range: 0x1AD2E0 -> 0x1AD3C0 unsigned int i; // r11 - class RpGeometry * geom; // r10 - class RpMaterial * material; // r25 - class RwRGBA * col; // r2 + class RpGeometry* geom; // r10 + class RpMaterial* material; // r25 + class RwRGBA* col; // r2 class RwRGBA new_col; // r29+0xC } } @@ -2283,12 +2499,15 @@ void iModelSetMaterialAlpha(class RpAtomic * model /* r2 */, unsigned char alpha Code range: 0x001AD3C0 -> 0x001AD680 */ // Range: 0x1AD3C0 -> 0x1AD680 -void iModelTagEval(class RpAtomic * model /* r19 */, class xModelTagWithNormal * tag /* r18 */, class RwMatrixTag * mat /* r17 */, class xVec3 * dest /* r2 */, class xVec3 * normal /* r16 */) { +void iModelTagEval(class RpAtomic* model /* r19 */, class xModelTagWithNormal* tag /* r18 */, + class RwMatrixTag* mat /* r17 */, class xVec3* dest /* r2 */, + class xVec3* normal /* r16 */) +{ // Blocks /* anonymous block */ { // Range: 0x1AD3C0 -> 0x1AD680 - class RpSkin * skin; // r2 - class RwMatrixTag * skinmat; // r29+0xC0 + class RpSkin* skin; // r2 + class RwMatrixTag* skinmat; // r29+0xC0 } } @@ -2299,13 +2518,15 @@ void iModelTagEval(class RpAtomic * model /* r19 */, class xModelTagWithNormal * Code range: 0x001AD680 -> 0x001AD960 */ // Range: 0x1AD680 -> 0x1AD960 -void iModelTagEval(class RpAtomic * model /* r2 */, class xModelTag * tag /* r19 */, class RwMatrixTag * mat /* r18 */, class xVec3 * dest /* r17 */) { +void iModelTagEval(class RpAtomic* model /* r2 */, class xModelTag* tag /* r19 */, + class RwMatrixTag* mat /* r18 */, class xVec3* dest /* r17 */) +{ // Blocks /* anonymous block */ { // Range: 0x1AD680 -> 0x1AD960 - class RpGeometry * geom; // r2 - class RpSkin * skin; // r2 - class RwMatrixTag * skinmat; // r29+0xA0 + class RpGeometry* geom; // r2 + class RpSkin* skin; // r2 + class RwMatrixTag* skinmat; // r29+0xA0 } } @@ -2316,12 +2537,15 @@ void iModelTagEval(class RpAtomic * model /* r2 */, class xModelTag * tag /* r19 Code range: 0x001AD960 -> 0x001AD9C8 */ // Range: 0x1AD960 -> 0x1AD9C8 -unsigned int iModelTagSetup(class xModelTagWithNormal * tag /* r16 */, class RpAtomic * model /* r17 */, float x /* r29+0x30 */, float y /* r29+0x30 */, float z /* r29+0x30 */) { +unsigned int iModelTagSetup(class xModelTagWithNormal* tag /* r16 */, + class RpAtomic* model /* r17 */, float x /* r29+0x30 */, + float y /* r29+0x30 */, float z /* r29+0x30 */) +{ // Blocks /* anonymous block */ { // Range: 0x1AD960 -> 0x1AD9C8 unsigned int index; // r2 - class xVec3 * normals; // r3 + class xVec3* normals; // r3 } } @@ -2332,7 +2556,9 @@ unsigned int iModelTagSetup(class xModelTagWithNormal * tag /* r16 */, class RpA Code range: 0x001AD9D0 -> 0x001AD9D8 */ // Range: 0x1AD9D0 -> 0x1AD9D8 -unsigned int iModelTagSetup(class xModelTag * tag /* r2 */, class RpAtomic * model /* r2 */, float x /* r29 */, float y /* r29 */, float z /* r29 */) { +unsigned int iModelTagSetup(class xModelTag* tag /* r2 */, class RpAtomic* model /* r2 */, + float x /* r29 */, float y /* r29 */, float z /* r29 */) +{ // Blocks /* anonymous block */ { // Range: 0x1AD9D0 -> 0x1AD9D8 @@ -2346,18 +2572,22 @@ unsigned int iModelTagSetup(class xModelTag * tag /* r2 */, class RpAtomic * mod Code range: 0x001AD9E0 -> 0x001ADB88 */ // Range: 0x1AD9E0 -> 0x1ADB88 -static unsigned int iModelTagInternal(class xModelTag * tag /* r17 */, class RpAtomic * model /* r2 */, float x /* r29+0x40 */, float y /* r29+0x40 */, float z /* r29+0x40 */, signed int closeV /* r16 */) { +static unsigned int iModelTagInternal(class xModelTag* tag /* r17 */, + class RpAtomic* model /* r2 */, float x /* r29+0x40 */, + float y /* r29+0x40 */, float z /* r29+0x40 */, + signed int closeV /* r16 */) +{ // Blocks /* anonymous block */ { // Range: 0x1AD9E0 -> 0x1ADB88 - class RpGeometry * geom; // r3 - class RwV3d * vert; // r7 + class RpGeometry* geom; // r3 + class RwV3d* vert; // r7 signed int v; // r4 signed int numV; // r3 float distSqr; // r29+0x40 float closeDistSqr; // r3 - class RpSkin * skin; // r18 - class RwMatrixWeights * wt; // r18 + class RpSkin* skin; // r18 + class RwMatrixWeights* wt; // r18 } } @@ -2368,19 +2598,23 @@ static unsigned int iModelTagInternal(class xModelTag * tag /* r17 */, class RpA Code range: 0x001ADB90 -> 0x001ADDC4 */ // Range: 0x1ADB90 -> 0x1ADDC4 -static unsigned int iModelTagUserData(class xModelTag * tag /* r21 */, class RpAtomic * model /* r20 */, float x /* r22 */, float y /* r21 */, float z /* r20 */, signed int closeV /* r19 */) { +static unsigned int iModelTagUserData(class xModelTag* tag /* r21 */, + class RpAtomic* model /* r20 */, float x /* r22 */, + float y /* r21 */, float z /* r20 */, + signed int closeV /* r19 */) +{ // Blocks /* anonymous block */ { // Range: 0x1ADB90 -> 0x1ADDC4 signed int i; // r18 signed int count; // r17 - class RpUserDataArray * array; // r16 - class RpUserDataArray * testarray; // r22 + class RpUserDataArray* array; // r16 + class RpUserDataArray* testarray; // r22 float distSqr; // r29+0x90 float closeDistSqr; // r3 signed int numTags; // r6 signed int t; // r5 - class xModelTag * tagList; // r4 + class xModelTag* tagList; // r4 } } @@ -2391,16 +2625,19 @@ static unsigned int iModelTagUserData(class xModelTag * tag /* r21 */, class RpA Code range: 0x001ADDD0 -> 0x001AE158 */ // Range: 0x1ADDD0 -> 0x1AE158 -unsigned int iModelNormalEval(class xVec3 * out /* r18 */, class RpAtomic & m /* r2 */, class RwMatrixTag * mat /* r29+0xF0 */, unsigned int index /* r16 */, signed int size /* r29+0xE0 */, class xVec3 * in /* r22 */) { +unsigned int iModelNormalEval(class xVec3* out /* r18 */, class RpAtomic& m /* r2 */, + class RwMatrixTag* mat /* r29+0xF0 */, unsigned int index /* r16 */, + signed int size /* r29+0xE0 */, class xVec3* in /* r22 */) +{ // Blocks /* anonymous block */ { // Range: 0x1ADDD0 -> 0x1AE158 - class RpGeometry * geom; // r2 + class RpGeometry* geom; // r2 signed int max_size; // r3 - class RpSkin * skin; // r17 - class RwMatrixTag * skin_mats; // r29+0xD0 - float * bone_weights; // r29+0xC0 - unsigned int * bone_indices; // r23 + class RpSkin* skin; // r17 + class RwMatrixTag* skin_mats; // r29+0xD0 + float* bone_weights; // r29+0xC0 + unsigned int* bone_indices; // r23 class xMat4x3 nmat; // r29+0x100 } } @@ -2412,13 +2649,16 @@ unsigned int iModelNormalEval(class xVec3 * out /* r18 */, class RpAtomic & m /* Code range: 0x001AE160 -> 0x001AE4E0 */ // Range: 0x1AE160 -> 0x1AE4E0 -unsigned int iModelVertEval(class RpAtomic * model /* r2 */, unsigned int index /* r16 */, unsigned int count /* r20 */, class RwMatrixTag * mat /* r19 */, class xVec3 * vert /* r18 */, class xVec3 * dest /* r17 */) { +unsigned int iModelVertEval(class RpAtomic* model /* r2 */, unsigned int index /* r16 */, + unsigned int count /* r20 */, class RwMatrixTag* mat /* r19 */, + class xVec3* vert /* r18 */, class xVec3* dest /* r17 */) +{ // Blocks /* anonymous block */ { // Range: 0x1AE160 -> 0x1AE4E0 - class RpGeometry * geom; // r3 + class RpGeometry* geom; // r3 unsigned int numV; // r2 - class RpSkin * skin; // r21 + class RpSkin* skin; // r21 } } @@ -2429,12 +2669,13 @@ unsigned int iModelVertEval(class RpAtomic * model /* r2 */, unsigned int index Code range: 0x001AE4E0 -> 0x001AE664 */ // Range: 0x1AE4E0 -> 0x1AE664 -void iModel_SetLightKit(class xLightKit * lightKit /* r2 */) { +void iModel_SetLightKit(class xLightKit* lightKit /* r2 */) +{ // Blocks /* anonymous block */ { // Range: 0x1AE4E0 -> 0x1AE664 - class RpLight * amb; // r10 - class RpLight * dir[4]; // r29+0x30 + class RpLight* amb; // r10 + class RpLight* dir[4]; // r29+0x30 signed int lightTypes[5]; // r29+0x10 unsigned int i; // r7 } @@ -2447,7 +2688,8 @@ void iModel_SetLightKit(class xLightKit * lightKit /* r2 */) { Code range: 0x001AE670 -> 0x001AE67C */ // Range: 0x1AE670 -> 0x1AE67C -unsigned int iModelVertCount(class RpAtomic * model /* r2 */) { +unsigned int iModelVertCount(class RpAtomic* model /* r2 */) +{ // Blocks /* anonymous block */ { // Range: 0x1AE670 -> 0x1AE67C @@ -2461,18 +2703,21 @@ unsigned int iModelVertCount(class RpAtomic * model /* r2 */) { Code range: 0x001AE680 -> 0x001AE8F0 */ // Range: 0x1AE680 -> 0x1AE8F0 -signed int iModelCullPlusShadow(class RpAtomic * model /* r18 */, class RwMatrixTag * mat /* r20 */, class xVec3 * shadowVec /* r17 */, signed int * shadowOutside /* r16 */) { +signed int iModelCullPlusShadow(class RpAtomic* model /* r18 */, class RwMatrixTag* mat /* r20 */, + class xVec3* shadowVec /* r17 */, + signed int* shadowOutside /* r16 */) +{ // Blocks /* anonymous block */ { // Range: 0x1AE680 -> 0x1AE8F0 float xScale2; // r8 float yScale2; // r5 float zScale2; // r1 - class RwV3d * up; // r2 - class RwV3d * at; // r2 - class RwCamera * cam; // r19 + class RwV3d* up; // r2 + class RwV3d* at; // r2 + class RwCamera* cam; // r19 class RwSphere worldsph; // r29+0x60 - class RwFrustumPlane * frustumPlane; // r6 + class RwFrustumPlane* frustumPlane; // r6 signed int numPlanes; // r5 float nDot; // r29+0x70 float nDot; // r2 @@ -2487,7 +2732,8 @@ signed int iModelCullPlusShadow(class RpAtomic * model /* r18 */, class RwMatrix Code range: 0x001AE8F0 -> 0x001AE91C */ // Range: 0x1AE8F0 -> 0x1AE91C -signed int iModelSphereCull(class xSphere * sphere /* r2 */) { +signed int iModelSphereCull(class xSphere* sphere /* r2 */) +{ // Blocks /* anonymous block */ { // Range: 0x1AE8F0 -> 0x1AE91C @@ -2501,7 +2747,8 @@ signed int iModelSphereCull(class xSphere * sphere /* r2 */) { Code range: 0x001AE920 -> 0x001AEA40 */ // Range: 0x1AE920 -> 0x1AEA40 -signed int iModelCull(class RpAtomic * model /* r2 */, class RwMatrixTag * mat /* r2 */) { +signed int iModelCull(class RpAtomic* model /* r2 */, class RwMatrixTag* mat /* r2 */) +{ // Blocks /* anonymous block */ { // Range: 0x1AE920 -> 0x1AEA40 @@ -2515,12 +2762,13 @@ signed int iModelCull(class RpAtomic * model /* r2 */, class RwMatrixTag * mat / Code range: 0x001AEA40 -> 0x001AEBD0 */ // Range: 0x1AEA40 -> 0x1AEBD0 -void iModelRender(class RpAtomic * model /* r20 */, class RwMatrixTag * mat /* r19 */) { +void iModelRender(class RpAtomic* model /* r20 */, class RwMatrixTag* mat /* r19 */) +{ // Blocks /* anonymous block */ { // Range: 0x1AEA40 -> 0x1AEBD0 - class RwMatrixTag * pAnimOldMatrix; // r18 - class RwFrame * frame; // r3 + class RwMatrixTag* pAnimOldMatrix; // r18 + class RwFrame* frame; // r3 } } @@ -2531,18 +2779,20 @@ void iModelRender(class RpAtomic * model /* r20 */, class RwMatrixTag * mat /* r Code range: 0x001AEBD0 -> 0x001AEDEC */ // Range: 0x1AEBD0 -> 0x1AEDEC -void iModelAnimMatrices(class RpAtomic * model /* r2 */, class xQuat * quat /* r18 */, class xVec3 * tran /* r17 */, class RwMatrixTag * mat /* r16 */) { +void iModelAnimMatrices(class RpAtomic* model /* r2 */, class xQuat* quat /* r18 */, + class xVec3* tran /* r17 */, class RwMatrixTag* mat /* r16 */) +{ // Blocks /* anonymous block */ { // Range: 0x1AEBD0 -> 0x1AEDEC - class RpHAnimHierarchy * pHierarchy; // r3 + class RpHAnimHierarchy* pHierarchy; // r3 class RwMatrixTag matrixStack[32]; // r29+0x50 - class RwMatrixTag * pMatrixStackTop; // r11 - class RpHAnimNodeInfo * pCurrentFrame; // r7 + class RwMatrixTag* pMatrixStackTop; // r11 + class RpHAnimNodeInfo* pCurrentFrame; // r7 signed int pCurrentFrameFlags; // r6 signed int i; // r5 signed int numFrames; // r4 - class RwMatrixTag * pMatrixArray; // r2 + class RwMatrixTag* pMatrixArray; // r2 } } @@ -2553,7 +2803,8 @@ void iModelAnimMatrices(class RpAtomic * model /* r2 */, class xQuat * quat /* r Code range: 0x001AEDF0 -> 0x001AEE68 */ // Range: 0x1AEDF0 -> 0x1AEE68 -unsigned int iModelNumBones(class RpAtomic * model /* r2 */) { +unsigned int iModelNumBones(class RpAtomic* model /* r2 */) +{ // Blocks /* anonymous block */ { // Range: 0x1AEDF0 -> 0x1AEE68 @@ -2567,12 +2818,13 @@ unsigned int iModelNumBones(class RpAtomic * model /* r2 */) { Code range: 0x001AEE70 -> 0x001AEEB4 */ // Range: 0x1AEE70 -> 0x1AEEB4 -class RpAtomic * iModelFile_RWMultiAtomic(class RpAtomic * model /* r2 */) { +class RpAtomic* iModelFile_RWMultiAtomic(class RpAtomic* model /* r2 */) +{ // Blocks /* anonymous block */ { // Range: 0x1AEE70 -> 0x1AEEB4 - class RpClump * clump; // r2 - class RpAtomic * nextModel; // r29+0x1C + class RpClump* clump; // r2 + class RpAtomic* nextModel; // r29+0x1C } } @@ -2583,11 +2835,12 @@ class RpAtomic * iModelFile_RWMultiAtomic(class RpAtomic * model /* r2 */) { Code range: 0x001AEEC0 -> 0x001AEEF0 */ // Range: 0x1AEEC0 -> 0x1AEEF0 -static class RpAtomic * NextAtomicCallback(class RpAtomic * atomic /* r2 */, void * data /* r2 */) { +static class RpAtomic* NextAtomicCallback(class RpAtomic* atomic /* r2 */, void* data /* r2 */) +{ // Blocks /* anonymous block */ { // Range: 0x1AEEC0 -> 0x1AEEF0 - class RpAtomic * * nextModel; // r2 + class RpAtomic** nextModel; // r2 } } @@ -2598,13 +2851,14 @@ static class RpAtomic * NextAtomicCallback(class RpAtomic * atomic /* r2 */, voi Code range: 0x001AEEF0 -> 0x001AEF5C */ // Range: 0x1AEEF0 -> 0x1AEF5C -void iModelUnload(class RpAtomic * userdata /* r2 */) { +void iModelUnload(class RpAtomic* userdata /* r2 */) +{ // Blocks /* anonymous block */ { // Range: 0x1AEEF0 -> 0x1AEF5C - class RpClump * clump; // r17 - class RwFrame * frame; // r16 - class RwFrame * root; // r2 + class RpClump* clump; // r17 + class RwFrame* frame; // r16 + class RwFrame* root; // r2 } } @@ -2615,7 +2869,8 @@ void iModelUnload(class RpAtomic * userdata /* r2 */) { Code range: 0x001AEF60 -> 0x001AEF94 */ // Range: 0x1AEF60 -> 0x1AEF94 -class RpAtomic * iModelFileNew(void * buffer /* r2 */, unsigned int size /* r2 */) { +class RpAtomic* iModelFileNew(void* buffer /* r2 */, unsigned int size /* r2 */) +{ // Blocks /* anonymous block */ { // Range: 0x1AEF60 -> 0x1AEF94 @@ -2630,11 +2885,12 @@ class RpAtomic * iModelFileNew(void * buffer /* r2 */, unsigned int size /* r2 * Code range: 0x001AEFA0 -> 0x001AF1C4 */ // Range: 0x1AEFA0 -> 0x1AF1C4 -static class RpAtomic * iModelStreamRead(class RwStream * stream /* r17 */) { +static class RpAtomic* iModelStreamRead(class RwStream* stream /* r17 */) +{ // Blocks /* anonymous block */ { // Range: 0x1AEFA0 -> 0x1AF1C4 - class RpClump * clump; // r16 + class RpClump* clump; // r16 unsigned int i; // r5 unsigned int maxIndex; // r2 float maxRadius; // r7 @@ -2649,12 +2905,13 @@ static class RpAtomic * iModelStreamRead(class RwStream * stream /* r17 */) { Code range: 0x001AF1D0 -> 0x001AF2F8 */ // Range: 0x1AF1D0 -> 0x1AF2F8 -static class RpAtomic * FindAtomicCallback(class RpAtomic * atomic /* r17 */) { +static class RpAtomic* FindAtomicCallback(class RpAtomic* atomic /* r17 */) +{ // Blocks /* anonymous block */ { // Range: 0x1AF1D0 -> 0x1AF2F8 - class RpHAnimHierarchy * pHier; // r19 - class RpSkin * pSkin; // r18 + class RpHAnimHierarchy* pHier; // r19 + class RpSkin* pSkin; // r18 } } @@ -2665,11 +2922,12 @@ static class RpAtomic * FindAtomicCallback(class RpAtomic * atomic /* r17 */) { Code range: 0x001AF300 -> 0x001AF3BC */ // Range: 0x1AF300 -> 0x1AF3BC -void iModelInit() { +void iModelInit() +{ // Blocks /* anonymous block */ { // Range: 0x1AF300 -> 0x1AF3BC - class RwFrame * frame; // r2 + class RwFrame* frame; // r2 class RwRGBAReal black; // r29+0x30 signed int i; // r17 } @@ -2682,11 +2940,11 @@ void iModelInit() { Code range: 0x001AF3C0 -> 0x001AF41C */ // Range: 0x1AF3C0 -> 0x1AF41C -static class RwFrame * GetChildFrameHierarchy(class RwFrame * frame /* r17 */, void * data /* r16 */) { +static class RwFrame* GetChildFrameHierarchy(class RwFrame* frame /* r17 */, void* data /* r16 */) +{ // Blocks /* anonymous block */ { // Range: 0x1AF3C0 -> 0x1AF41C - class RpHAnimHierarchy * hierarchy; // r2 + class RpHAnimHierarchy* hierarchy; // r2 } } - diff --git a/dwarf/SB/Core/x/xParSys.cpp b/dwarf/SB/Core/x/xParSys.cpp index 15fa17e5e..5ce9597dc 100644 --- a/dwarf/SB/Core/x/xParSys.cpp +++ b/dwarf/SB/Core/x/xParSys.cpp @@ -11,39 +11,44 @@ static class xVec3 par_offset_up; // size: 0xC, address: 0x5CE8A0 static class xParSysInfo sParSysInfo[7]; // size: 0x38, address: 0x4DF990 class zGlobals globals; // size: 0x2050, address: 0x52C8F0 unsigned int gActiveHeap; // size: 0x4, address: 0x50FA44 -signed int xParSysEventCB(class xBase *, class xBase *, unsigned int, float *, class xBase *); // size: 0x0, address: 0x2FBE00 +signed int xParSysEventCB(class xBase*, class xBase*, unsigned int, float*, + class xBase*); // size: 0x0, address: 0x2FBE00 signed int _rpPTankAtomicDataOffset; // size: 0x4, address: 0x50F128 -class xAnimFile { +class xAnimFile +{ // total size: 0x20 public: - class xAnimFile * Next; // offset 0x0, size 0x4 - char * Name; // offset 0x4, size 0x4 + class xAnimFile* Next; // offset 0x0, size 0x4 + char* Name; // offset 0x4, size 0x4 unsigned int ID; // offset 0x8, size 0x4 unsigned int FileFlags; // offset 0xC, size 0x4 float Duration; // offset 0x10, size 0x4 float TimeOffset; // offset 0x14, size 0x4 unsigned short BoneCount; // offset 0x18, size 0x2 unsigned char NumAnims[2]; // offset 0x1A, size 0x2 - void * * RawData; // offset 0x1C, size 0x4 + void** RawData; // offset 0x1C, size 0x4 }; -class xBase { +class xBase +{ // total size: 0x10 public: unsigned int id; // offset 0x0, size 0x4 unsigned char baseType; // offset 0x4, size 0x1 unsigned char linkCount; // offset 0x5, size 0x1 unsigned short baseFlags; // offset 0x6, size 0x2 - class xLinkAsset * link; // offset 0x8, size 0x4 - signed int (* eventFunc)(class xBase *, class xBase *, unsigned int, float *, class xBase *); // offset 0xC, size 0x4 + class xLinkAsset* link; // offset 0x8, size 0x4 + signed int (*eventFunc)(class xBase*, class xBase*, unsigned int, float*, + class xBase*); // offset 0xC, size 0x4 }; -class zLedgeGrabParams { +class zLedgeGrabParams +{ // total size: 0x380 public: float animGrab; // offset 0x0, size 0x4 float zdist; // offset 0x4, size 0x4 class xVec3 tranTable[60]; // offset 0x8, size 0x2D0 signed int tranCount; // offset 0x2D8, size 0x4 - class xEnt * optr; // offset 0x2DC, size 0x4 + class xEnt* optr; // offset 0x2DC, size 0x4 class xMat4x3 omat; // offset 0x2E0, size 0x40 float y0det; // offset 0x320, size 0x4 float dydet; // offset 0x324, size 0x4 @@ -61,32 +66,37 @@ class zLedgeGrabParams { float startrot; // offset 0x36C, size 0x4 float endrot; // offset 0x370, size 0x4 }; -class RwV3d { +class RwV3d +{ // total size: 0xC public: float x; // offset 0x0, size 0x4 float y; // offset 0x4, size 0x4 float z; // offset 0x8, size 0x4 }; -class zScene : public xScene { +class zScene : public xScene +{ // total size: 0x2C8 public: - class _zPortal * pendingPortal; // offset 0x70, size 0x4 - union { // inferred + class _zPortal* pendingPortal; // offset 0x70, size 0x4 + union + { // inferred unsigned int num_ents; // offset 0x74, size 0x4 unsigned int num_base; // offset 0x74, size 0x4 }; - union { // inferred - class xBase * * base; // offset 0x78, size 0x4 - class zEnt * * ents; // offset 0x78, size 0x4 + union + { // inferred + class xBase** base; // offset 0x78, size 0x4 + class zEnt** ents; // offset 0x78, size 0x4 }; unsigned int num_update_base; // offset 0x7C, size 0x4 - class xBase * * update_base; // offset 0x80, size 0x4 + class xBase** update_base; // offset 0x80, size 0x4 unsigned int baseCount[72]; // offset 0x84, size 0x120 - class xBase * baseList[72]; // offset 0x1A4, size 0x120 - class _zEnv * zen; // offset 0x2C4, size 0x4 + class xBase* baseList[72]; // offset 0x1A4, size 0x120 + class _zEnv* zen; // offset 0x2C4, size 0x4 }; -class xLightKitLight { +class xLightKitLight +{ // total size: 0x60 public: unsigned int type; // offset 0x0, size 0x4 @@ -94,13 +104,14 @@ class xLightKitLight { float matrix[16]; // offset 0x14, size 0x40 float radius; // offset 0x54, size 0x4 float angle; // offset 0x58, size 0x4 - class RpLight * platLight; // offset 0x5C, size 0x4 + class RpLight* platLight; // offset 0x5C, size 0x4 }; -class xParGroup { +class xParGroup +{ // total size: 0x24 public: - class xPar * m_root; // offset 0x0, size 0x4 - class xPar * m_dead; // offset 0x4, size 0x4 + class xPar* m_root; // offset 0x0, size 0x4 + class xPar* m_dead; // offset 0x4, size 0x4 signed int m_num_of_particles; // offset 0x8, size 0x4 unsigned char m_alive; // offset 0xC, size 0x1 unsigned char m_killWhenDead; // offset 0xD, size 0x1 @@ -110,38 +121,43 @@ class xParGroup { unsigned char m_priority; // offset 0x11, size 0x1 unsigned char m_flags; // offset 0x12, size 0x1 unsigned char m_regidx; // offset 0x13, size 0x1 - class xParGroup * m_next; // offset 0x14, size 0x4 - class xParGroup * m_prev; // offset 0x18, size 0x4 - void (* draw)(void *, class xParGroup *); // offset 0x1C, size 0x4 - class xParCmdTex * m_cmdTex; // offset 0x20, size 0x4 + class xParGroup* m_next; // offset 0x14, size 0x4 + class xParGroup* m_prev; // offset 0x18, size 0x4 + void (*draw)(void*, class xParGroup*); // offset 0x1C, size 0x4 + class xParCmdTex* m_cmdTex; // offset 0x20, size 0x4 }; -class RxPipelineNode { +class RxPipelineNode +{ // total size: 0x28 public: - class RxNodeDefinition * nodeDef; // offset 0x0, size 0x4 + class RxNodeDefinition* nodeDef; // offset 0x0, size 0x4 unsigned int numOutputs; // offset 0x4, size 0x4 - unsigned int * outputs; // offset 0x8, size 0x4 - class RxPipelineCluster * * slotClusterRefs; // offset 0xC, size 0x4 - unsigned int * slotsContinue; // offset 0x10, size 0x4 - void * privateData; // offset 0x14, size 0x4 - unsigned int * inputToClusterSlot; // offset 0x18, size 0x4 - class RxPipelineNodeTopSortData * topSortData; // offset 0x1C, size 0x4 - void * initializationData; // offset 0x20, size 0x4 + unsigned int* outputs; // offset 0x8, size 0x4 + class RxPipelineCluster** slotClusterRefs; // offset 0xC, size 0x4 + unsigned int* slotsContinue; // offset 0x10, size 0x4 + void* privateData; // offset 0x14, size 0x4 + unsigned int* inputToClusterSlot; // offset 0x18, size 0x4 + class RxPipelineNodeTopSortData* topSortData; // offset 0x1C, size 0x4 + void* initializationData; // offset 0x20, size 0x4 unsigned int initializationDataSize; // offset 0x24, size 0x4 }; -class rxHeapFreeBlock { +class rxHeapFreeBlock +{ // total size: 0x8 public: unsigned int size; // offset 0x0, size 0x4 - class rxHeapBlockHeader * ptr; // offset 0x4, size 0x4 + class rxHeapBlockHeader* ptr; // offset 0x4, size 0x4 }; -class xAnimTransition { +class xAnimTransition +{ // total size: 0x2C public: - class xAnimTransition * Next; // offset 0x0, size 0x4 - class xAnimState * Dest; // offset 0x4, size 0x4 - unsigned int (* Conditional)(class xAnimTransition *, class xAnimSingle *, void *); // offset 0x8, size 0x4 - unsigned int (* Callback)(class xAnimTransition *, class xAnimSingle *, void *); // offset 0xC, size 0x4 + class xAnimTransition* Next; // offset 0x0, size 0x4 + class xAnimState* Dest; // offset 0x4, size 0x4 + unsigned int (*Conditional)(class xAnimTransition*, class xAnimSingle*, + void*); // offset 0x8, size 0x4 + unsigned int (*Callback)(class xAnimTransition*, class xAnimSingle*, + void*); // offset 0xC, size 0x4 unsigned int Flags; // offset 0x10, size 0x4 unsigned int UserFlags; // offset 0x14, size 0x4 float SrcTime; // offset 0x18, size 0x4 @@ -149,21 +165,23 @@ class xAnimTransition { unsigned short Priority; // offset 0x20, size 0x2 unsigned short QueuePriority; // offset 0x22, size 0x2 float BlendRecip; // offset 0x24, size 0x4 - unsigned short * BlendOffset; // offset 0x28, size 0x4 + unsigned short* BlendOffset; // offset 0x28, size 0x4 }; -class /* @class */ { +class /* @class */ +{ // total size: 0xC public: float t; // offset 0x0, size 0x4 float u; // offset 0x4, size 0x4 float v; // offset 0x8, size 0x4 }; -class RwRaster { +class RwRaster +{ // total size: 0x34 public: - class RwRaster * parent; // offset 0x0, size 0x4 - unsigned char * cpPixels; // offset 0x4, size 0x4 - unsigned char * palette; // offset 0x8, size 0x4 + class RwRaster* parent; // offset 0x0, size 0x4 + unsigned char* cpPixels; // offset 0x4, size 0x4 + unsigned char* palette; // offset 0x8, size 0x4 signed int width; // offset 0xC, size 0x4 signed int height; // offset 0x10, size 0x4 signed int depth; // offset 0x14, size 0x4 @@ -174,50 +192,55 @@ class RwRaster { unsigned char cFlags; // offset 0x21, size 0x1 unsigned char privateFlags; // offset 0x22, size 0x1 unsigned char cFormat; // offset 0x23, size 0x1 - unsigned char * originalPixels; // offset 0x24, size 0x4 + unsigned char* originalPixels; // offset 0x24, size 0x4 signed int originalWidth; // offset 0x28, size 0x4 signed int originalHeight; // offset 0x2C, size 0x4 signed int originalStride; // offset 0x30, size 0x4 }; -class RxPipelineNodeTopSortData { +class RxPipelineNodeTopSortData +{ // total size: 0xC public: unsigned int numIns; // offset 0x0, size 0x4 unsigned int numInsVisited; // offset 0x4, size 0x4 - class rxReq * req; // offset 0x8, size 0x4 + class rxReq* req; // offset 0x8, size 0x4 }; -class xAnimSingle { +class xAnimSingle +{ // total size: 0x40 public: unsigned int SingleFlags; // offset 0x0, size 0x4 - class xAnimState * State; // offset 0x4, size 0x4 + class xAnimState* State; // offset 0x4, size 0x4 float Time; // offset 0x8, size 0x4 float CurrentSpeed; // offset 0xC, size 0x4 float BilinearLerp[2]; // offset 0x10, size 0x8 - class xAnimEffect * Effect; // offset 0x18, size 0x4 + class xAnimEffect* Effect; // offset 0x18, size 0x4 unsigned int ActiveCount; // offset 0x1C, size 0x4 float LastTime; // offset 0x20, size 0x4 - class xAnimActiveEffect * ActiveList; // offset 0x24, size 0x4 - class xAnimPlay * Play; // offset 0x28, size 0x4 - class xAnimTransition * Sync; // offset 0x2C, size 0x4 - class xAnimTransition * Tran; // offset 0x30, size 0x4 - class xAnimSingle * Blend; // offset 0x34, size 0x4 + class xAnimActiveEffect* ActiveList; // offset 0x24, size 0x4 + class xAnimPlay* Play; // offset 0x28, size 0x4 + class xAnimTransition* Sync; // offset 0x2C, size 0x4 + class xAnimTransition* Tran; // offset 0x30, size 0x4 + class xAnimSingle* Blend; // offset 0x34, size 0x4 float BlendFactor; // offset 0x38, size 0x4 unsigned int pad; // offset 0x3C, size 0x4 }; -class RpPolygon { +class RpPolygon +{ // total size: 0x8 public: unsigned short matIndex; // offset 0x0, size 0x2 unsigned short vertIndex[3]; // offset 0x2, size 0x6 }; -class RwV2d { +class RwV2d +{ // total size: 0x8 public: float x; // offset 0x0, size 0x4 float y; // offset 0x4, size 0x4 }; -class xShadowSimpleCache { +class xShadowSimpleCache +{ // total size: 0x98 public: unsigned short flags; // offset 0x0, size 0x2 @@ -226,7 +249,7 @@ class xShadowSimpleCache { unsigned int collPriority; // offset 0x4, size 0x4 class xVec3 pos; // offset 0x8, size 0xC class xVec3 at; // offset 0x14, size 0xC - class xEnt * castOnEnt; // offset 0x20, size 0x4 + class xEnt* castOnEnt; // offset 0x20, size 0x4 class xShadowSimplePoly poly; // offset 0x24, size 0x30 float envHeight; // offset 0x54, size 0x4 float shadowHeight; // offset 0x58, size 0x4 @@ -235,32 +258,36 @@ class xShadowSimpleCache { float dydz; // offset 0x64, size 0x4 class xVec3 corner[4]; // offset 0x68, size 0x30 }; -class xUpdateCullEnt { +class xUpdateCullEnt +{ // total size: 0x10 public: unsigned short index; // offset 0x0, size 0x2 signed short groupIndex; // offset 0x2, size 0x2 - unsigned int (* cb)(void *, void *); // offset 0x4, size 0x4 - void * cbdata; // offset 0x8, size 0x4 - class xUpdateCullEnt * nextInGroup; // offset 0xC, size 0x4 + unsigned int (*cb)(void*, void*); // offset 0x4, size 0x4 + void* cbdata; // offset 0x8, size 0x4 + class xUpdateCullEnt* nextInGroup; // offset 0xC, size 0x4 }; -class xAnimActiveEffect { +class xAnimActiveEffect +{ // total size: 0x8 public: - class xAnimEffect * Effect; // offset 0x0, size 0x4 + class xAnimEffect* Effect; // offset 0x0, size 0x4 unsigned int Handle; // offset 0x4, size 0x4 }; -class RxNodeDefinition { +class RxNodeDefinition +{ // total size: 0x40 public: - char * name; // offset 0x0, size 0x4 + char* name; // offset 0x0, size 0x4 class RxNodeMethods nodeMethods; // offset 0x4, size 0x1C class RxIoSpec io; // offset 0x20, size 0x14 unsigned int pipelineNodePrivateDataSize; // offset 0x34, size 0x4 enum RxNodeDefEditable editable; // offset 0x38, size 0x4 signed int InputPipesCnt; // offset 0x3C, size 0x4 }; -class xParCmdTex : public xParCmdAsset { +class xParCmdTex : public xParCmdAsset +{ // total size: 0x24 public: float x1; // offset 0x8, size 0x4 @@ -274,81 +301,90 @@ class xParCmdTex : public xParCmdAsset { float unit_width; // offset 0x1C, size 0x4 float unit_height; // offset 0x20, size 0x4 }; -class ptank_pool__pos_color_size_uv2 : public ptank_pool { +class ptank_pool__pos_color_size_uv2 : public ptank_pool +{ // total size: 0x38 public: - class xVec3 * pos; // offset 0x24, size 0x4 - class iColor_tag * color; // offset 0x28, size 0x4 - class xVec2 * size; // offset 0x2C, size 0x4 - class xVec2 * uv; // offset 0x30, size 0x4 + class xVec3* pos; // offset 0x24, size 0x4 + class iColor_tag* color; // offset 0x28, size 0x4 + class xVec2* size; // offset 0x2C, size 0x4 + class xVec2* uv; // offset 0x30, size 0x4 signed int stride; // offset 0x34, size 0x4 }; -class xEntShadow { +class xEntShadow +{ // total size: 0x28 public: class xVec3 pos; // offset 0x0, size 0xC class xVec3 vec; // offset 0xC, size 0xC - class RpAtomic * shadowModel; // offset 0x18, size 0x4 + class RpAtomic* shadowModel; // offset 0x18, size 0x4 float dst_cast; // offset 0x1C, size 0x4 float radius[2]; // offset 0x20, size 0x8 }; -class RpMaterialList { +class RpMaterialList +{ // total size: 0xC public: - class RpMaterial * * materials; // offset 0x0, size 0x4 + class RpMaterial** materials; // offset 0x0, size 0x4 signed int numMaterials; // offset 0x4, size 0x4 signed int space; // offset 0x8, size 0x4 }; -enum _zPlayerWallJumpState { +enum _zPlayerWallJumpState +{ k_WALLJUMP_NOT = 0, k_WALLJUMP_LAUNCH = 1, k_WALLJUMP_FLIGHT = 2, k_WALLJUMP_LAND = 3, }; -class xParCmd { +class xParCmd +{ // total size: 0x8 public: unsigned int flag; // offset 0x0, size 0x4 - class xParCmdAsset * tasset; // offset 0x4, size 0x4 + class xParCmdAsset* tasset; // offset 0x4, size 0x4 }; -class RpAtomic { +class RpAtomic +{ // total size: 0x70 public: class RwObjectHasFrame object; // offset 0x0, size 0x14 - class RwResEntry * repEntry; // offset 0x14, size 0x4 - class RpGeometry * geometry; // offset 0x18, size 0x4 + class RwResEntry* repEntry; // offset 0x14, size 0x4 + class RpGeometry* geometry; // offset 0x18, size 0x4 class RwSphere boundingSphere; // offset 0x1C, size 0x10 class RwSphere worldBoundingSphere; // offset 0x2C, size 0x10 - class RpClump * clump; // offset 0x3C, size 0x4 + class RpClump* clump; // offset 0x3C, size 0x4 class RwLLLink inClumpLink; // offset 0x40, size 0x8 - class RpAtomic * (* renderCallBack)(class RpAtomic *); // offset 0x48, size 0x4 + class RpAtomic* (*renderCallBack)(class RpAtomic*); // offset 0x48, size 0x4 class RpInterpolator interpolator; // offset 0x4C, size 0x14 unsigned short renderFrame; // offset 0x60, size 0x2 unsigned short pad; // offset 0x62, size 0x2 class RwLinkList llWorldSectorsInAtomic; // offset 0x64, size 0x8 - class RxPipeline * pipeline; // offset 0x6C, size 0x4 + class RxPipeline* pipeline; // offset 0x6C, size 0x4 }; -class xAnimPlay { +class xAnimPlay +{ // total size: 0x20 public: - class xAnimPlay * Next; // offset 0x0, size 0x4 + class xAnimPlay* Next; // offset 0x0, size 0x4 unsigned short NumSingle; // offset 0x4, size 0x2 unsigned short BoneCount; // offset 0x6, size 0x2 - class xAnimSingle * Single; // offset 0x8, size 0x4 - void * Object; // offset 0xC, size 0x4 - class xAnimTable * Table; // offset 0x10, size 0x4 - class xMemPool * Pool; // offset 0x14, size 0x4 - class xModelInstance * ModelInst; // offset 0x18, size 0x4 - void (* BeforeAnimMatrices)(class xAnimPlay *, class xQuat *, class xVec3 *, signed int); // offset 0x1C, size 0x4 -}; -class xModelInstance { + class xAnimSingle* Single; // offset 0x8, size 0x4 + void* Object; // offset 0xC, size 0x4 + class xAnimTable* Table; // offset 0x10, size 0x4 + class xMemPool* Pool; // offset 0x14, size 0x4 + class xModelInstance* ModelInst; // offset 0x18, size 0x4 + void (*BeforeAnimMatrices)(class xAnimPlay*, class xQuat*, class xVec3*, + signed int); // offset 0x1C, size 0x4 +}; +class xModelInstance +{ // total size: 0x6C public: - class xModelInstance * Next; // offset 0x0, size 0x4 - class xModelInstance * Parent; // offset 0x4, size 0x4 - class xModelPool * Pool; // offset 0x8, size 0x4 - class xAnimPlay * Anim; // offset 0xC, size 0x4 - class RpAtomic * Data; // offset 0x10, size 0x4 + class xModelInstance* Next; // offset 0x0, size 0x4 + class xModelInstance* Parent; // offset 0x4, size 0x4 + class xModelPool* Pool; // offset 0x8, size 0x4 + class xAnimPlay* Anim; // offset 0xC, size 0x4 + class RpAtomic* Data; // offset 0x10, size 0x4 unsigned int PipeFlags; // offset 0x14, size 0x4 float RedMultiplier; // offset 0x18, size 0x4 float GreenMultiplier; // offset 0x1C, size 0x4 @@ -356,30 +392,32 @@ class xModelInstance { float Alpha; // offset 0x24, size 0x4 float FadeStart; // offset 0x28, size 0x4 float FadeEnd; // offset 0x2C, size 0x4 - class xSurface * Surf; // offset 0x30, size 0x4 - class xModelBucket * * Bucket; // offset 0x34, size 0x4 - class xModelInstance * BucketNext; // offset 0x38, size 0x4 - class xLightKit * LightKit; // offset 0x3C, size 0x4 - void * Object; // offset 0x40, size 0x4 + class xSurface* Surf; // offset 0x30, size 0x4 + class xModelBucket** Bucket; // offset 0x34, size 0x4 + class xModelInstance* BucketNext; // offset 0x38, size 0x4 + class xLightKit* LightKit; // offset 0x3C, size 0x4 + void* Object; // offset 0x40, size 0x4 unsigned short Flags; // offset 0x44, size 0x2 unsigned char BoneCount; // offset 0x46, size 0x1 unsigned char BoneIndex; // offset 0x47, size 0x1 - unsigned char * BoneRemap; // offset 0x48, size 0x4 - class RwMatrixTag * Mat; // offset 0x4C, size 0x4 + unsigned char* BoneRemap; // offset 0x48, size 0x4 + class RwMatrixTag* Mat; // offset 0x4C, size 0x4 class xVec3 Scale; // offset 0x50, size 0xC unsigned int modelID; // offset 0x5C, size 0x4 unsigned int shadowID; // offset 0x60, size 0x4 - class RpAtomic * shadowmapAtomic; // offset 0x64, size 0x4 - class /* @class */ { + class RpAtomic* shadowmapAtomic; // offset 0x64, size 0x4 + class /* @class */ + { // total size: 0x4 public: - class xVec3 * verts; // offset 0x0, size 0x4 + class xVec3* verts; // offset 0x0, size 0x4 } anim_coll; // offset 0x68, size 0x4 }; -class xEnt : public xBase { +class xEnt : public xBase +{ // total size: 0xD0 public: - class xEntAsset * asset; // offset 0x10, size 0x4 + class xEntAsset* asset; // offset 0x10, size 0x4 unsigned short idx; // offset 0x14, size 0x2 unsigned short num_updates; // offset 0x16, size 0x2 unsigned char flags; // offset 0x18, size 0x1 @@ -394,166 +432,184 @@ class xEnt : public xBase { unsigned char collLev; // offset 0x21, size 0x1 unsigned char chkby; // offset 0x22, size 0x1 unsigned char penby; // offset 0x23, size 0x1 - class xModelInstance * model; // offset 0x24, size 0x4 - class xModelInstance * collModel; // offset 0x28, size 0x4 - class xModelInstance * camcollModel; // offset 0x2C, size 0x4 - class xLightKit * lightKit; // offset 0x30, size 0x4 - void (* update)(class xEnt *, class xScene *, float); // offset 0x34, size 0x4 - void (* endUpdate)(class xEnt *, class xScene *, float); // offset 0x38, size 0x4 - void (* bupdate)(class xEnt *, class xVec3 *); // offset 0x3C, size 0x4 - void (* move)(class xEnt *, class xScene *, float, class xEntFrame *); // offset 0x40, size 0x4 - void (* render)(class xEnt *); // offset 0x44, size 0x4 - class xEntFrame * frame; // offset 0x48, size 0x4 - class xEntCollis * collis; // offset 0x4C, size 0x4 + class xModelInstance* model; // offset 0x24, size 0x4 + class xModelInstance* collModel; // offset 0x28, size 0x4 + class xModelInstance* camcollModel; // offset 0x2C, size 0x4 + class xLightKit* lightKit; // offset 0x30, size 0x4 + void (*update)(class xEnt*, class xScene*, float); // offset 0x34, size 0x4 + void (*endUpdate)(class xEnt*, class xScene*, float); // offset 0x38, size 0x4 + void (*bupdate)(class xEnt*, class xVec3*); // offset 0x3C, size 0x4 + void (*move)(class xEnt*, class xScene*, float, class xEntFrame*); // offset 0x40, size 0x4 + void (*render)(class xEnt*); // offset 0x44, size 0x4 + class xEntFrame* frame; // offset 0x48, size 0x4 + class xEntCollis* collis; // offset 0x4C, size 0x4 class xGridBound gridb; // offset 0x50, size 0x14 class xBound bound; // offset 0x64, size 0x4C - void (* transl)(class xEnt *, class xVec3 *, class xMat4x3 *); // offset 0xB0, size 0x4 - class xFFX * ffx; // offset 0xB4, size 0x4 - class xEnt * driver; // offset 0xB8, size 0x4 + void (*transl)(class xEnt*, class xVec3*, class xMat4x3*); // offset 0xB0, size 0x4 + class xFFX* ffx; // offset 0xB4, size 0x4 + class xEnt* driver; // offset 0xB8, size 0x4 signed int driveMode; // offset 0xBC, size 0x4 - class xShadowSimpleCache * simpShadow; // offset 0xC0, size 0x4 - class xEntShadow * entShadow; // offset 0xC4, size 0x4 - class anim_coll_data * anim_coll; // offset 0xC8, size 0x4 - void * user_data; // offset 0xCC, size 0x4 + class xShadowSimpleCache* simpShadow; // offset 0xC0, size 0x4 + class xEntShadow* entShadow; // offset 0xC4, size 0x4 + class anim_coll_data* anim_coll; // offset 0xC8, size 0x4 + void* user_data; // offset 0xCC, size 0x4 }; -class rxHeapSuperBlockDescriptor { +class rxHeapSuperBlockDescriptor +{ // total size: 0xC public: - void * start; // offset 0x0, size 0x4 + void* start; // offset 0x0, size 0x4 unsigned int size; // offset 0x4, size 0x4 - class rxHeapSuperBlockDescriptor * next; // offset 0x8, size 0x4 + class rxHeapSuperBlockDescriptor* next; // offset 0x8, size 0x4 }; -class xVec3 { +class xVec3 +{ // total size: 0xC public: float x; // offset 0x0, size 0x4 float y; // offset 0x4, size 0x4 float z; // offset 0x8, size 0x4 }; -class iEnv { +class iEnv +{ // total size: 0x30 public: - class RpWorld * world; // offset 0x0, size 0x4 - class RpWorld * collision; // offset 0x4, size 0x4 - class RpWorld * fx; // offset 0x8, size 0x4 - class RpWorld * camera; // offset 0xC, size 0x4 - class xJSPHeader * jsp; // offset 0x10, size 0x4 - class RpLight * light[2]; // offset 0x14, size 0x8 - class RwFrame * light_frame[2]; // offset 0x1C, size 0x8 + class RpWorld* world; // offset 0x0, size 0x4 + class RpWorld* collision; // offset 0x4, size 0x4 + class RpWorld* fx; // offset 0x8, size 0x4 + class RpWorld* camera; // offset 0xC, size 0x4 + class xJSPHeader* jsp; // offset 0x10, size 0x4 + class RpLight* light[2]; // offset 0x14, size 0x8 + class RwFrame* light_frame[2]; // offset 0x1C, size 0x8 signed int memlvl; // offset 0x24, size 0x4 }; -class RxPipeline { +class RxPipeline +{ // total size: 0x34 public: signed int locked; // offset 0x0, size 0x4 unsigned int numNodes; // offset 0x4, size 0x4 - class RxPipelineNode * nodes; // offset 0x8, size 0x4 + class RxPipelineNode* nodes; // offset 0x8, size 0x4 unsigned int packetNumClusterSlots; // offset 0xC, size 0x4 enum rxEmbeddedPacketState embeddedPacketState; // offset 0x10, size 0x4 - class RxPacket * embeddedPacket; // offset 0x14, size 0x4 + class RxPacket* embeddedPacket; // offset 0x14, size 0x4 unsigned int numInputRequirements; // offset 0x18, size 0x4 - class RxPipelineRequiresCluster * inputRequirements; // offset 0x1C, size 0x4 - void * superBlock; // offset 0x20, size 0x4 + class RxPipelineRequiresCluster* inputRequirements; // offset 0x1C, size 0x4 + void* superBlock; // offset 0x20, size 0x4 unsigned int superBlockSize; // offset 0x24, size 0x4 unsigned int entryPoint; // offset 0x28, size 0x4 unsigned int pluginId; // offset 0x2C, size 0x4 unsigned int pluginData; // offset 0x30, size 0x4 }; -class RxPipelineCluster { +class RxPipelineCluster +{ // total size: 0x8 public: - class RxClusterDefinition * clusterRef; // offset 0x0, size 0x4 + class RxClusterDefinition* clusterRef; // offset 0x0, size 0x4 unsigned int creationAttributes; // offset 0x4, size 0x4 }; -class anim_coll_data { +class anim_coll_data +{ // total size: 0x0 }; -class RpMaterial { +class RpMaterial +{ // total size: 0x1C public: - class RwTexture * texture; // offset 0x0, size 0x4 + class RwTexture* texture; // offset 0x0, size 0x4 class RwRGBA color; // offset 0x4, size 0x4 - class RxPipeline * pipeline; // offset 0x8, size 0x4 + class RxPipeline* pipeline; // offset 0x8, size 0x4 class RwSurfaceProperties surfaceProps; // offset 0xC, size 0xC signed short refCount; // offset 0x18, size 0x2 signed short pad; // offset 0x1A, size 0x2 }; -class render_state { +class render_state +{ // total size: 0x10 public: - class RwTexture * texture; // offset 0x0, size 0x4 + class RwTexture* texture; // offset 0x0, size 0x4 unsigned int src_blend; // offset 0x4, size 0x4 unsigned int dst_blend; // offset 0x8, size 0x4 unsigned int flags; // offset 0xC, size 0x4 }; -class _tagEmitSphere { +class _tagEmitSphere +{ // total size: 0x4 public: float radius; // offset 0x0, size 0x4 }; -class xAnimState { +class xAnimState +{ // total size: 0x4C public: - class xAnimState * Next; // offset 0x0, size 0x4 - char * Name; // offset 0x4, size 0x4 + class xAnimState* Next; // offset 0x0, size 0x4 + char* Name; // offset 0x4, size 0x4 unsigned int ID; // offset 0x8, size 0x4 unsigned int Flags; // offset 0xC, size 0x4 unsigned int UserFlags; // offset 0x10, size 0x4 float Speed; // offset 0x14, size 0x4 - class xAnimFile * Data; // offset 0x18, size 0x4 - class xAnimEffect * Effects; // offset 0x1C, size 0x4 - class xAnimTransitionList * Default; // offset 0x20, size 0x4 - class xAnimTransitionList * List; // offset 0x24, size 0x4 - float * BoneBlend; // offset 0x28, size 0x4 - float * TimeSnap; // offset 0x2C, size 0x4 + class xAnimFile* Data; // offset 0x18, size 0x4 + class xAnimEffect* Effects; // offset 0x1C, size 0x4 + class xAnimTransitionList* Default; // offset 0x20, size 0x4 + class xAnimTransitionList* List; // offset 0x24, size 0x4 + float* BoneBlend; // offset 0x28, size 0x4 + float* TimeSnap; // offset 0x2C, size 0x4 float FadeRecip; // offset 0x30, size 0x4 - unsigned short * FadeOffset; // offset 0x34, size 0x4 - void * CallbackData; // offset 0x38, size 0x4 - class xAnimMultiFile * MultiFile; // offset 0x3C, size 0x4 - void (* BeforeEnter)(class xAnimPlay *, class xAnimState *); // offset 0x40, size 0x4 - void (* StateCallback)(class xAnimState *, class xAnimSingle *, void *); // offset 0x44, size 0x4 - void (* BeforeAnimMatrices)(class xAnimPlay *, class xQuat *, class xVec3 *, signed int); // offset 0x48, size 0x4 -}; -class xModelPool { + unsigned short* FadeOffset; // offset 0x34, size 0x4 + void* CallbackData; // offset 0x38, size 0x4 + class xAnimMultiFile* MultiFile; // offset 0x3C, size 0x4 + void (*BeforeEnter)(class xAnimPlay*, class xAnimState*); // offset 0x40, size 0x4 + void (*StateCallback)(class xAnimState*, class xAnimSingle*, void*); // offset 0x44, size 0x4 + void (*BeforeAnimMatrices)(class xAnimPlay*, class xQuat*, class xVec3*, + signed int); // offset 0x48, size 0x4 +}; +class xModelPool +{ // total size: 0xC public: - class xModelPool * Next; // offset 0x0, size 0x4 + class xModelPool* Next; // offset 0x0, size 0x4 unsigned int NumMatrices; // offset 0x4, size 0x4 - class xModelInstance * List; // offset 0x8, size 0x4 + class xModelInstance* List; // offset 0x8, size 0x4 }; -class xAnimMultiFile : public xAnimMultiFileBase { +class xAnimMultiFile : public xAnimMultiFileBase +{ // total size: 0xC public: class xAnimMultiFileEntry Files[1]; // offset 0x4, size 0x8 }; -class ptank_pool { +class ptank_pool +{ // total size: 0x24 public: class render_state rs; // offset 0x0, size 0x10 unsigned int used; // offset 0x10, size 0x4 - class RpAtomic * ptank; // offset 0x14, size 0x4 - class /* @class */ { + class RpAtomic* ptank; // offset 0x14, size 0x4 + class /* @class */ + { // total size: 0xC public: - unsigned char * data; // offset 0x0, size 0x4 + unsigned char* data; // offset 0x0, size 0x4 signed int stride; // offset 0x4, size 0x4 unsigned int size; // offset 0x8, size 0x4 } hide; // offset 0x18, size 0xC }; -class RxPipelineNodeParam { +class RxPipelineNodeParam +{ // total size: 0x8 public: - void * dataParam; // offset 0x0, size 0x4 - class RxHeap * heap; // offset 0x4, size 0x4 + void* dataParam; // offset 0x0, size 0x4 + class RxHeap* heap; // offset 0x4, size 0x4 }; -class xParEmitterAsset : public xBaseAsset { +class xParEmitterAsset : public xBaseAsset +{ // total size: 0x54 public: unsigned char emit_flags; // offset 0x8, size 0x1 unsigned char emit_type; // offset 0x9, size 0x1 unsigned short pad; // offset 0xA, size 0x2 unsigned int propID; // offset 0xC, size 0x4 - union { // inferred + union + { // inferred class xPECircle e_circle; // offset 0x10, size 0x14 class _tagEmitSphere e_sphere; // offset 0x10, size 0x4 class _tagEmitRect e_rect; // offset 0x10, size 0x8 @@ -571,48 +627,54 @@ class xParEmitterAsset : public xBaseAsset { unsigned int cull_mode; // offset 0x4C, size 0x4 float cull_dist_sqr; // offset 0x50, size 0x4 }; -class zEnt : public xEnt { +class zEnt : public xEnt +{ // total size: 0xD4 public: - class xAnimTable * atbl; // offset 0xD0, size 0x4 + class xAnimTable* atbl; // offset 0xD0, size 0x4 }; -class xLightKit { +class xLightKit +{ // total size: 0x10 public: unsigned int tagID; // offset 0x0, size 0x4 unsigned int groupID; // offset 0x4, size 0x4 unsigned int lightCount; // offset 0x8, size 0x4 - class xLightKitLight * lightList; // offset 0xC, size 0x4 + class xLightKitLight* lightList; // offset 0xC, size 0x4 }; -class RwTexture { +class RwTexture +{ // total size: 0x58 public: - class RwRaster * raster; // offset 0x0, size 0x4 - class RwTexDictionary * dict; // offset 0x4, size 0x4 + class RwRaster* raster; // offset 0x0, size 0x4 + class RwTexDictionary* dict; // offset 0x4, size 0x4 class RwLLLink lInDictionary; // offset 0x8, size 0x8 char name[32]; // offset 0x10, size 0x20 char mask[32]; // offset 0x30, size 0x20 unsigned int filterAddressing; // offset 0x50, size 0x4 signed int refCount; // offset 0x54, size 0x4 }; -class RxHeap { +class RxHeap +{ // total size: 0x1C public: unsigned int superBlockSize; // offset 0x0, size 0x4 - class rxHeapSuperBlockDescriptor * head; // offset 0x4, size 0x4 - class rxHeapBlockHeader * headBlock; // offset 0x8, size 0x4 - class rxHeapFreeBlock * freeBlocks; // offset 0xC, size 0x4 + class rxHeapSuperBlockDescriptor* head; // offset 0x4, size 0x4 + class rxHeapBlockHeader* headBlock; // offset 0x8, size 0x4 + class rxHeapFreeBlock* freeBlocks; // offset 0xC, size 0x4 unsigned int entriesAlloced; // offset 0x10, size 0x4 unsigned int entriesUsed; // offset 0x14, size 0x4 signed int dirty; // offset 0x18, size 0x4 }; -class xJSPNodeInfo { +class xJSPNodeInfo +{ // total size: 0x8 public: signed int originalMatIndex; // offset 0x0, size 0x4 signed int nodeFlags; // offset 0x4, size 0x4 }; -class RwRGBA { +class RwRGBA +{ // total size: 0x4 public: unsigned char red; // offset 0x0, size 0x1 @@ -620,13 +682,15 @@ class RwRGBA { unsigned char blue; // offset 0x2, size 0x1 unsigned char alpha; // offset 0x3, size 0x1 }; -class RwBBox { +class RwBBox +{ // total size: 0x18 public: class RwV3d sup; // offset 0x0, size 0xC class RwV3d inf; // offset 0xC, size 0xC }; -enum _tagRumbleType { +enum _tagRumbleType +{ eRumble_Off = 0, eRumble_Hi = 1, eRumble_VeryLightHi = 2, @@ -642,7 +706,8 @@ enum _tagRumbleType { eRumble_Total = 12, eRumbleForceU32 = 2147483647, }; -class xLinkAsset { +class xLinkAsset +{ // total size: 0x20 public: unsigned short srcEvent; // offset 0x0, size 0x2 @@ -652,21 +717,24 @@ class xLinkAsset { unsigned int paramWidgetAssetID; // offset 0x18, size 0x4 unsigned int chkAssetID; // offset 0x1C, size 0x4 }; -enum _zPlayerType { +enum _zPlayerType +{ ePlayer_SB = 0, ePlayer_Patrick = 1, ePlayer_Sandy = 2, ePlayer_MAXTYPES = 3, }; -class xUpdateCullGroup { +class xUpdateCullGroup +{ // total size: 0xC public: unsigned int active; // offset 0x0, size 0x4 unsigned short startIndex; // offset 0x4, size 0x2 unsigned short endIndex; // offset 0x6, size 0x2 - class xGroup * groupObject; // offset 0x8, size 0x4 + class xGroup* groupObject; // offset 0x8, size 0x4 }; -class RpClump { +class RpClump +{ // total size: 0x2C public: class RwObject object; // offset 0x0, size 0x8 @@ -674,15 +742,17 @@ class RpClump { class RwLinkList lightList; // offset 0x10, size 0x8 class RwLinkList cameraList; // offset 0x18, size 0x8 class RwLLLink inWorldLink; // offset 0x20, size 0x8 - class RpClump * (* callback)(class RpClump *, void *); // offset 0x28, size 0x4 + class RpClump* (*callback)(class RpClump*, void*); // offset 0x28, size 0x4 }; -class xQuat { +class xQuat +{ // total size: 0x10 public: class xVec3 v; // offset 0x0, size 0xC float s; // offset 0xC, size 0x4 }; -class xParSysAsset : public xBaseAsset { +class xParSysAsset : public xBaseAsset +{ // total size: 0x20 public: unsigned int type; // offset 0x8, size 0x4 @@ -697,13 +767,15 @@ class xParSysAsset : public xBaseAsset { unsigned char cmdCount; // offset 0x1B, size 0x1 unsigned int cmdSize; // offset 0x1C, size 0x4 }; -class RwTexCoords { +class RwTexCoords +{ // total size: 0x8 public: float u; // offset 0x0, size 0x4 float v; // offset 0x4, size 0x4 }; -class RpGeometry { +class RpGeometry +{ // total size: 0x60 public: class RwObject object; // offset 0x0, size 0x8 @@ -715,45 +787,48 @@ class RpGeometry { signed int numMorphTargets; // offset 0x18, size 0x4 signed int numTexCoordSets; // offset 0x1C, size 0x4 class RpMaterialList matList; // offset 0x20, size 0xC - class RpTriangle * triangles; // offset 0x2C, size 0x4 - class RwRGBA * preLitLum; // offset 0x30, size 0x4 - class RwTexCoords * texCoords[8]; // offset 0x34, size 0x20 - class RpMeshHeader * mesh; // offset 0x54, size 0x4 - class RwResEntry * repEntry; // offset 0x58, size 0x4 - class RpMorphTarget * morphTarget; // offset 0x5C, size 0x4 -}; -class RpWorldSector { + class RpTriangle* triangles; // offset 0x2C, size 0x4 + class RwRGBA* preLitLum; // offset 0x30, size 0x4 + class RwTexCoords* texCoords[8]; // offset 0x34, size 0x20 + class RpMeshHeader* mesh; // offset 0x54, size 0x4 + class RwResEntry* repEntry; // offset 0x58, size 0x4 + class RpMorphTarget* morphTarget; // offset 0x5C, size 0x4 +}; +class RpWorldSector +{ // total size: 0x90 public: signed int type; // offset 0x0, size 0x4 - class RpPolygon * polygons; // offset 0x4, size 0x4 - class RwV3d * vertices; // offset 0x8, size 0x4 - class RpVertexNormal * normals; // offset 0xC, size 0x4 - class RwTexCoords * texCoords[8]; // offset 0x10, size 0x20 - class RwRGBA * preLitLum; // offset 0x30, size 0x4 - class RwResEntry * repEntry; // offset 0x34, size 0x4 + class RpPolygon* polygons; // offset 0x4, size 0x4 + class RwV3d* vertices; // offset 0x8, size 0x4 + class RpVertexNormal* normals; // offset 0xC, size 0x4 + class RwTexCoords* texCoords[8]; // offset 0x10, size 0x20 + class RwRGBA* preLitLum; // offset 0x30, size 0x4 + class RwResEntry* repEntry; // offset 0x34, size 0x4 class RwLinkList collAtomicsInWorldSector; // offset 0x38, size 0x8 class RwLinkList noCollAtomicsInWorldSector; // offset 0x40, size 0x8 class RwLinkList lightsInWorldSector; // offset 0x48, size 0x8 class RwBBox boundingBox; // offset 0x50, size 0x18 class RwBBox tightBoundingBox; // offset 0x68, size 0x18 - class RpMeshHeader * mesh; // offset 0x80, size 0x4 - class RxPipeline * pipeline; // offset 0x84, size 0x4 + class RpMeshHeader* mesh; // offset 0x80, size 0x4 + class RxPipeline* pipeline; // offset 0x84, size 0x4 unsigned short matListWindowBase; // offset 0x88, size 0x2 unsigned short numVertices; // offset 0x8A, size 0x2 unsigned short numPolygons; // offset 0x8C, size 0x2 unsigned short pad; // offset 0x8E, size 0x2 }; -class rxHeapBlockHeader { +class rxHeapBlockHeader +{ // total size: 0x20 public: - class rxHeapBlockHeader * prev; // offset 0x0, size 0x4 - class rxHeapBlockHeader * next; // offset 0x4, size 0x4 + class rxHeapBlockHeader* prev; // offset 0x0, size 0x4 + class rxHeapBlockHeader* next; // offset 0x4, size 0x4 unsigned int size; // offset 0x8, size 0x4 - class rxHeapFreeBlock * freeEntry; // offset 0xC, size 0x4 + class rxHeapFreeBlock* freeEntry; // offset 0xC, size 0x4 unsigned int pad[4]; // offset 0x10, size 0x10 }; -class analog_data { +class analog_data +{ // total size: 0x18 public: class xVec2 offset; // offset 0x0, size 0x8 @@ -761,36 +836,40 @@ class analog_data { float mag; // offset 0x10, size 0x4 float ang; // offset 0x14, size 0x4 }; -class xAnimTable { +class xAnimTable +{ // total size: 0x1C public: - class xAnimTable * Next; // offset 0x0, size 0x4 - char * Name; // offset 0x4, size 0x4 - class xAnimTransition * TransitionList; // offset 0x8, size 0x4 - class xAnimState * StateList; // offset 0xC, size 0x4 + class xAnimTable* Next; // offset 0x0, size 0x4 + char* Name; // offset 0x4, size 0x4 + class xAnimTransition* TransitionList; // offset 0x8, size 0x4 + class xAnimState* StateList; // offset 0xC, size 0x4 unsigned int AnimIndex; // offset 0x10, size 0x4 unsigned int MorphIndex; // offset 0x14, size 0x4 unsigned int UserFlags; // offset 0x18, size 0x4 }; -class xParSys : public xBase { +class xParSys : public xBase +{ // total size: 0x2C public: - class xParSysAsset * tasset; // offset 0x10, size 0x4 + class xParSysAsset* tasset; // offset 0x10, size 0x4 unsigned int cmdCount; // offset 0x14, size 0x4 - class xParCmd * cmd; // offset 0x18, size 0x4 - class xParSys * parent; // offset 0x1C, size 0x4 - class xParGroup * group; // offset 0x20, size 0x4 + class xParCmd* cmd; // offset 0x18, size 0x4 + class xParSys* parent; // offset 0x1C, size 0x4 + class xParGroup* group; // offset 0x20, size 0x4 unsigned char visible; // offset 0x24, size 0x1 - class RwTexture * txtr_particle; // offset 0x28, size 0x4 + class RwTexture* txtr_particle; // offset 0x28, size 0x4 }; -class RxPipelineRequiresCluster { +class RxPipelineRequiresCluster +{ // total size: 0xC public: - class RxClusterDefinition * clusterDef; // offset 0x0, size 0x4 + class RxClusterDefinition* clusterDef; // offset 0x0, size 0x4 enum RxClusterValidityReq rqdOrOpt; // offset 0x4, size 0x4 unsigned int slotIndex; // offset 0x8, size 0x4 }; -class xClumpCollBSPBranchNode { +class xClumpCollBSPBranchNode +{ // total size: 0x10 public: unsigned int leftInfo; // offset 0x0, size 0x4 @@ -798,33 +877,37 @@ class xClumpCollBSPBranchNode { float leftValue; // offset 0x8, size 0x4 float rightValue; // offset 0xC, size 0x4 }; -class RpMorphTarget { +class RpMorphTarget +{ // total size: 0x1C public: - class RpGeometry * parentGeom; // offset 0x0, size 0x4 + class RpGeometry* parentGeom; // offset 0x0, size 0x4 class RwSphere boundingSphere; // offset 0x4, size 0x10 - class RwV3d * verts; // offset 0x14, size 0x4 - class RwV3d * normals; // offset 0x18, size 0x4 + class RwV3d* verts; // offset 0x14, size 0x4 + class RwV3d* normals; // offset 0x18, size 0x4 }; -class xGroup : public xBase { +class xGroup : public xBase +{ // total size: 0x20 public: - class xGroupAsset * asset; // offset 0x10, size 0x4 - class xBase * * item; // offset 0x14, size 0x4 + class xGroupAsset* asset; // offset 0x10, size 0x4 + class xBase** item; // offset 0x14, size 0x4 unsigned int last_index; // offset 0x18, size 0x4 signed int flg_group; // offset 0x1C, size 0x4 }; -class _tagEmitRect { +class _tagEmitRect +{ // total size: 0x8 public: float x_len; // offset 0x0, size 0x4 float z_len; // offset 0x4, size 0x4 }; -class xPar { +class xPar +{ // total size: 0x60 public: - class xPar * m_next; // offset 0x0, size 0x4 - class xPar * m_prev; // offset 0x4, size 0x4 + class xPar* m_next; // offset 0x0, size 0x4 + class xPar* m_prev; // offset 0x4, size 0x4 float m_lifetime; // offset 0x8, size 0x4 unsigned char m_c[4]; // offset 0xC, size 0x4 class xVec3 m_pos; // offset 0x10, size 0xC @@ -837,20 +920,23 @@ class xPar { unsigned char m_rotdeg[3]; // offset 0x34, size 0x3 unsigned char pad8; // offset 0x37, size 0x1 float totalLifespan; // offset 0x38, size 0x4 - class xParEmitterAsset * m_asset; // offset 0x3C, size 0x4 + class xParEmitterAsset* m_asset; // offset 0x3C, size 0x4 float m_cvel[4]; // offset 0x40, size 0x10 float m_cfl[4]; // offset 0x50, size 0x10 }; -class xAnimEffect { +class xAnimEffect +{ // total size: 0x14 public: - class xAnimEffect * Next; // offset 0x0, size 0x4 + class xAnimEffect* Next; // offset 0x0, size 0x4 unsigned int Flags; // offset 0x4, size 0x4 float StartTime; // offset 0x8, size 0x4 float EndTime; // offset 0xC, size 0x4 - unsigned int (* Callback)(unsigned int, class xAnimActiveEffect *, class xAnimSingle *, void *); // offset 0x10, size 0x4 + unsigned int (*Callback)(unsigned int, class xAnimActiveEffect*, class xAnimSingle*, + void*); // offset 0x10, size 0x4 }; -class RpVertexNormal { +class RpVertexNormal +{ // total size: 0x4 public: signed char x; // offset 0x0, size 0x1 @@ -858,36 +944,41 @@ class RpVertexNormal { signed char z; // offset 0x2, size 0x1 unsigned char pad; // offset 0x3, size 0x1 }; -class xBound { +class xBound +{ // total size: 0x4C public: class xQCData qcd; // offset 0x0, size 0x20 unsigned char type; // offset 0x20, size 0x1 unsigned char pad[3]; // offset 0x21, size 0x3 - union { // inferred + union + { // inferred class xSphere sph; // offset 0x24, size 0x10 class xBBox box; // offset 0x24, size 0x24 class xCylinder cyl; // offset 0x24, size 0x14 }; - class xMat4x3 * mat; // offset 0x48, size 0x4 + class xMat4x3* mat; // offset 0x48, size 0x4 }; -class xJSPHeader { +class xJSPHeader +{ // total size: 0x18 public: char idtag[4]; // offset 0x0, size 0x4 unsigned int version; // offset 0x4, size 0x4 unsigned int jspNodeCount; // offset 0x8, size 0x4 - class RpClump * clump; // offset 0xC, size 0x4 - class xClumpCollBSPTree * colltree; // offset 0x10, size 0x4 - class xJSPNodeInfo * jspNodeList; // offset 0x14, size 0x4 + class RpClump* clump; // offset 0xC, size 0x4 + class xClumpCollBSPTree* colltree; // offset 0x10, size 0x4 + class xJSPNodeInfo* jspNodeList; // offset 0x14, size 0x4 }; -class xVec2 { +class xVec2 +{ // total size: 0x8 public: float x; // offset 0x0, size 0x4 float y; // offset 0x4, size 0x4 }; -class xBaseAsset { +class xBaseAsset +{ // total size: 0x8 public: unsigned int id; // offset 0x0, size 0x4 @@ -895,33 +986,36 @@ class xBaseAsset { unsigned char linkCount; // offset 0x5, size 0x1 unsigned short baseFlags; // offset 0x6, size 0x2 }; -class zCheckPoint { +class zCheckPoint +{ // total size: 0x14 public: class xVec3 pos; // offset 0x0, size 0xC float rot; // offset 0xC, size 0x4 unsigned int initCamID; // offset 0x10, size 0x4 }; -class xMat4x3 : public xMat3x3 { +class xMat4x3 : public xMat3x3 +{ // total size: 0x40 public: class xVec3 pos; // offset 0x30, size 0xC unsigned int pad3; // offset 0x3C, size 0x4 }; -class zPlayerGlobals { +class zPlayerGlobals +{ // total size: 0x1940 public: class zEnt ent; // offset 0x0, size 0xD4 class xEntShadow entShadow_embedded; // offset 0xD4, size 0x28 class xShadowSimpleCache simpShadow_embedded; // offset 0xFC, size 0x98 class zGlobalSettings g; // offset 0x194, size 0x150 - class zPlayerSettings * s; // offset 0x2E4, size 0x4 + class zPlayerSettings* s; // offset 0x2E4, size 0x4 class zPlayerSettings sb; // offset 0x2F0, size 0x460 class zPlayerSettings patrick; // offset 0x750, size 0x460 class zPlayerSettings sandy; // offset 0xBB0, size 0x460 - class xModelInstance * model_spongebob; // offset 0x1010, size 0x4 - class xModelInstance * model_patrick; // offset 0x1014, size 0x4 - class xModelInstance * model_sandy; // offset 0x1018, size 0x4 + class xModelInstance* model_spongebob; // offset 0x1010, size 0x4 + class xModelInstance* model_patrick; // offset 0x1014, size 0x4 + class xModelInstance* model_sandy; // offset 0x1018, size 0x4 unsigned int Visible; // offset 0x101C, size 0x4 unsigned int Health; // offset 0x1020, size 0x4 signed int Speed; // offset 0x1024, size 0x4 @@ -943,7 +1037,7 @@ class zPlayerGlobals { float HotsauceTimer; // offset 0x1064, size 0x4 float LeanLerp; // offset 0x1068, size 0x4 float ScareTimer; // offset 0x106C, size 0x4 - class xBase * ScareSource; // offset 0x1070, size 0x4 + class xBase* ScareSource; // offset 0x1070, size 0x4 float CowerTimer; // offset 0x1074, size 0x4 float DamageTimer; // offset 0x1078, size 0x4 float SundaeTimer; // offset 0x107C, size 0x4 @@ -955,7 +1049,7 @@ class zPlayerGlobals { float HeadbuttVel; // offset 0x1094, size 0x4 float HeadbuttTimer; // offset 0x1098, size 0x4 unsigned int SpecialReceived; // offset 0x109C, size 0x4 - class xEnt * MountChimney; // offset 0x10A0, size 0x4 + class xEnt* MountChimney; // offset 0x10A0, size 0x4 float MountChimOldY; // offset 0x10A4, size 0x4 unsigned int MaxHealth; // offset 0x10A8, size 0x4 unsigned int DoMeleeCheck; // offset 0x10AC, size 0x4 @@ -976,24 +1070,24 @@ class zPlayerGlobals { float IdleMajorTimer; // offset 0x10E8, size 0x4 float IdleSitTimer; // offset 0x10EC, size 0x4 signed int Transparent; // offset 0x10F0, size 0x4 - class zEnt * FireTarget; // offset 0x10F4, size 0x4 + class zEnt* FireTarget; // offset 0x10F4, size 0x4 unsigned int ControlOff; // offset 0x10F8, size 0x4 unsigned int ControlOnEvent; // offset 0x10FC, size 0x4 unsigned int AutoMoveSpeed; // offset 0x1100, size 0x4 float AutoMoveDist; // offset 0x1104, size 0x4 class xVec3 AutoMoveTarget; // offset 0x1108, size 0xC - class xBase * AutoMoveObject; // offset 0x1114, size 0x4 - class zEnt * Diggable; // offset 0x1118, size 0x4 + class xBase* AutoMoveObject; // offset 0x1114, size 0x4 + class zEnt* Diggable; // offset 0x1118, size 0x4 float DigTimer; // offset 0x111C, size 0x4 class zPlayerCarryInfo carry; // offset 0x1120, size 0xE0 class zPlayerLassoInfo lassoInfo; // offset 0x1200, size 0x120 class xModelTag BubbleWandTag[2]; // offset 0x1320, size 0x40 - class xModelInstance * model_wand; // offset 0x1360, size 0x4 - class xEntBoulder * bubblebowl; // offset 0x1364, size 0x4 + class xModelInstance* model_wand; // offset 0x1360, size 0x4 + class xEntBoulder* bubblebowl; // offset 0x1364, size 0x4 float bbowlInitVel; // offset 0x1368, size 0x4 - class zEntHangable * HangFound; // offset 0x136C, size 0x4 - class zEntHangable * HangEnt; // offset 0x1370, size 0x4 - class zEntHangable * HangEntLast; // offset 0x1374, size 0x4 + class zEntHangable* HangFound; // offset 0x136C, size 0x4 + class zEntHangable* HangEnt; // offset 0x1370, size 0x4 + class zEntHangable* HangEntLast; // offset 0x1374, size 0x4 class xVec3 HangPivot; // offset 0x1378, size 0xC class xVec3 HangVel; // offset 0x1384, size 0xC float HangLength; // offset 0x1390, size 0x4 @@ -1008,7 +1102,7 @@ class zPlayerGlobals { signed int Jump_CanDouble; // offset 0x1438, size 0x4 signed int Jump_CanFloat; // offset 0x143C, size 0x4 signed int Jump_SpringboardStart; // offset 0x1440, size 0x4 - class zPlatform * Jump_Springboard; // offset 0x1444, size 0x4 + class zPlatform* Jump_Springboard; // offset 0x1444, size 0x4 signed int CanJump; // offset 0x1448, size 0x4 signed int CanBubbleSpin; // offset 0x144C, size 0x4 signed int CanBubbleBounce; // offset 0x1450, size 0x4 @@ -1033,7 +1127,7 @@ class zPlayerGlobals { unsigned int Inv_PatsSock_Total; // offset 0x1544, size 0x4 class xModelTag BubbleTag; // offset 0x1548, size 0x20 class xEntDrive drv; // offset 0x1568, size 0x7C - class xSurface * floor_surf; // offset 0x15E4, size 0x4 + class xSurface* floor_surf; // offset 0x15E4, size 0x4 class xVec3 floor_norm; // offset 0x15E8, size 0xC signed int slope; // offset 0x15F4, size 0x4 class xCollis earc_coll; // offset 0x15F8, size 0x50 @@ -1046,7 +1140,7 @@ class zPlayerGlobals { class zCheckPoint cp; // offset 0x16B8, size 0x14 unsigned int SlideTrackSliding; // offset 0x16CC, size 0x4 unsigned int SlideTrackCount; // offset 0x16D0, size 0x4 - class xEnt * SlideTrackEnt[111]; // offset 0x16D4, size 0x1BC + class xEnt* SlideTrackEnt[111]; // offset 0x16D4, size 0x1BC unsigned int SlideNotGroundedSinceSlide; // offset 0x1890, size 0x4 class xVec3 SlideTrackDir; // offset 0x1894, size 0xC class xVec3 SlideTrackVel; // offset 0x18A0, size 0xC @@ -1054,7 +1148,7 @@ class zPlayerGlobals { float SlideTrackLean; // offset 0x18B0, size 0x4 float SlideTrackLand; // offset 0x18B4, size 0x4 unsigned char sb_model_indices[14]; // offset 0x18B8, size 0xE - class xModelInstance * sb_models[14]; // offset 0x18C8, size 0x38 + class xModelInstance* sb_models[14]; // offset 0x18C8, size 0x38 unsigned int currentPlayer; // offset 0x1900, size 0x4 class xVec3 PredictRotate; // offset 0x1904, size 0xC class xVec3 PredictTranslate; // offset 0x1910, size 0xC @@ -1064,7 +1158,8 @@ class zPlayerGlobals { float KnockBackTimer; // offset 0x1930, size 0x4 float KnockIntoAirTimer; // offset 0x1934, size 0x4 }; -class xVec4 { +class xVec4 +{ // total size: 0x10 public: float x; // offset 0x0, size 0x4 @@ -1072,20 +1167,23 @@ class xVec4 { float z; // offset 0x8, size 0x4 float w; // offset 0xC, size 0x4 }; -class RwSurfaceProperties { +class RwSurfaceProperties +{ // total size: 0xC public: float ambient; // offset 0x0, size 0x4 float specular; // offset 0x4, size 0x4 float diffuse; // offset 0x8, size 0x4 }; -class xBBox { +class xBBox +{ // total size: 0x24 public: class xVec3 center; // offset 0x0, size 0xC class xBox box; // offset 0xC, size 0x18 }; -class RwMatrixTag { +class RwMatrixTag +{ // total size: 0x40 public: class RwV3d right; // offset 0x0, size 0xC @@ -1097,7 +1195,8 @@ class RwMatrixTag { class RwV3d pos; // offset 0x30, size 0xC unsigned int pad3; // offset 0x3C, size 0x4 }; -class RpMeshHeader { +class RpMeshHeader +{ // total size: 0x10 public: unsigned int flags; // offset 0x0, size 0x4 @@ -1106,22 +1205,24 @@ class RpMeshHeader { unsigned int totalIndicesInMesh; // offset 0x8, size 0x4 unsigned int firstMeshOffset; // offset 0xC, size 0x4 }; -class xUpdateCullMgr { +class xUpdateCullMgr +{ // total size: 0x2C public: unsigned int entCount; // offset 0x0, size 0x4 unsigned int entActive; // offset 0x4, size 0x4 - void * * ent; // offset 0x8, size 0x4 - class xUpdateCullEnt * * mgr; // offset 0xC, size 0x4 + void** ent; // offset 0x8, size 0x4 + class xUpdateCullEnt** mgr; // offset 0xC, size 0x4 unsigned int mgrCount; // offset 0x10, size 0x4 unsigned int mgrCurr; // offset 0x14, size 0x4 - class xUpdateCullEnt * mgrList; // offset 0x18, size 0x4 + class xUpdateCullEnt* mgrList; // offset 0x18, size 0x4 unsigned int grpCount; // offset 0x1C, size 0x4 - class xUpdateCullGroup * grpList; // offset 0x20, size 0x4 - void (* activateCB)(void *); // offset 0x24, size 0x4 - void (* deactivateCB)(void *); // offset 0x28, size 0x4 + class xUpdateCullGroup* grpList; // offset 0x20, size 0x4 + void (*activateCB)(void*); // offset 0x24, size 0x4 + void (*deactivateCB)(void*); // offset 0x28, size 0x4 }; -class xParCmdAsset { +class xParCmdAsset +{ // total size: 0x8 public: unsigned int type; // offset 0x0, size 0x4 @@ -1129,14 +1230,15 @@ class xParCmdAsset { unsigned char mode; // offset 0x5, size 0x1 unsigned char pad[2]; // offset 0x6, size 0x2 }; -class zPlayerCarryInfo { +class zPlayerCarryInfo +{ // total size: 0xE0 public: - class xEnt * grabbed; // offset 0x0, size 0x4 + class xEnt* grabbed; // offset 0x0, size 0x4 unsigned int grabbedModelID; // offset 0x4, size 0x4 class xMat4x3 spin; // offset 0x10, size 0x40 - class xEnt * throwTarget; // offset 0x50, size 0x4 - class xEnt * flyingToTarget; // offset 0x54, size 0x4 + class xEnt* throwTarget; // offset 0x50, size 0x4 + class xEnt* flyingToTarget; // offset 0x54, size 0x4 float minDist; // offset 0x58, size 0x4 float maxDist; // offset 0x5C, size 0x4 float minHeight; // offset 0x60, size 0x4 @@ -1166,41 +1268,46 @@ class zPlayerCarryInfo { float fruitCeilingBounce; // offset 0xC8, size 0x4 float fruitWallBounce; // offset 0xCC, size 0x4 float fruitLifetime; // offset 0xD0, size 0x4 - class xEnt * patLauncher; // offset 0xD4, size 0x4 + class xEnt* patLauncher; // offset 0xD4, size 0x4 }; -class RwResEntry { +class RwResEntry +{ // total size: 0x18 public: class RwLLLink link; // offset 0x0, size 0x8 signed int size; // offset 0x8, size 0x4 - void * owner; // offset 0xC, size 0x4 - class RwResEntry * * ownerRef; // offset 0x10, size 0x4 - void (* destroyNotify)(class RwResEntry *); // offset 0x14, size 0x4 + void* owner; // offset 0xC, size 0x4 + class RwResEntry** ownerRef; // offset 0x10, size 0x4 + void (*destroyNotify)(class RwResEntry*); // offset 0x14, size 0x4 }; -class xSerial { +class xSerial +{ // total size: 0x0 }; -class _zEnv : public xBase { +class _zEnv : public xBase +{ // total size: 0x14 public: - class xEnvAsset * easset; // offset 0x10, size 0x4 + class xEnvAsset* easset; // offset 0x10, size 0x4 }; -class rxReq { +class rxReq +{ // total size: 0x0 }; -class xCamera : public xBase { +class xCamera : public xBase +{ // total size: 0x330 public: - class RwCamera * lo_cam; // offset 0x10, size 0x4 + class RwCamera* lo_cam; // offset 0x10, size 0x4 class xMat4x3 mat; // offset 0x20, size 0x40 class xMat4x3 omat; // offset 0x60, size 0x40 class xMat3x3 mbasis; // offset 0xA0, size 0x30 class xBound bound; // offset 0xD0, size 0x4C - class xMat4x3 * tgt_mat; // offset 0x11C, size 0x4 - class xMat4x3 * tgt_omat; // offset 0x120, size 0x4 - class xBound * tgt_bound; // offset 0x124, size 0x4 + class xMat4x3* tgt_mat; // offset 0x11C, size 0x4 + class xMat4x3* tgt_omat; // offset 0x120, size 0x4 + class xBound* tgt_bound; // offset 0x124, size 0x4 class xVec3 focus; // offset 0x128, size 0xC - class xScene * sc; // offset 0x134, size 0x4 + class xScene* sc; // offset 0x134, size 0x4 class xVec3 tran_accum; // offset 0x138, size 0xC float fov; // offset 0x144, size 0x4 unsigned int flags; // offset 0x148, size 0x4 @@ -1268,20 +1375,22 @@ class xCamera : public xBase { float roll_csv; // offset 0x264, size 0x4 class xVec4 frustplane[12]; // offset 0x270, size 0xC0 }; -class xMemPool { +class xMemPool +{ // total size: 0x1C public: - void * FreeList; // offset 0x0, size 0x4 + void* FreeList; // offset 0x0, size 0x4 unsigned short NextOffset; // offset 0x4, size 0x2 unsigned short Flags; // offset 0x6, size 0x2 - void * UsedList; // offset 0x8, size 0x4 - void (* InitCB)(class xMemPool *, void *); // offset 0xC, size 0x4 - void * Buffer; // offset 0x10, size 0x4 + void* UsedList; // offset 0x8, size 0x4 + void (*InitCB)(class xMemPool*, void*); // offset 0xC, size 0x4 + void* Buffer; // offset 0x10, size 0x4 unsigned short Size; // offset 0x14, size 0x2 unsigned short NumRealloc; // offset 0x16, size 0x2 unsigned int Total; // offset 0x18, size 0x4 }; -class xPEEntBound { +class xPEEntBound +{ // total size: 0xC public: unsigned char flags; // offset 0x0, size 0x1 @@ -1291,7 +1400,8 @@ class xPEEntBound { float expand; // offset 0x4, size 0x4 float deflection; // offset 0x8, size 0x4 }; -class zPlayerSettings { +class zPlayerSettings +{ // total size: 0x460 public: enum _zPlayerType pcType; // offset 0x0, size 0x4 @@ -1318,30 +1428,33 @@ class zPlayerSettings { unsigned char talk_filter_size; // offset 0x459, size 0x1 unsigned char talk_filter[4]; // offset 0x45A, size 0x4 }; -enum RxClusterValidityReq { +enum RxClusterValidityReq +{ rxCLREQ_DONTWANT = 0, rxCLREQ_REQUIRED = 1, rxCLREQ_OPTIONAL = 2, rxCLUSTERVALIDITYREQFORCEENUMSIZEINT = 2147483647, }; -class xClumpCollBSPTree { +class xClumpCollBSPTree +{ // total size: 0x10 public: unsigned int numBranchNodes; // offset 0x0, size 0x4 - class xClumpCollBSPBranchNode * branchNodes; // offset 0x4, size 0x4 + class xClumpCollBSPBranchNode* branchNodes; // offset 0x4, size 0x4 unsigned int numTriangles; // offset 0x8, size 0x4 - class xClumpCollBSPTriangle * triangles; // offset 0xC, size 0x4 + class xClumpCollBSPTriangle* triangles; // offset 0xC, size 0x4 }; -class RwCamera { +class RwCamera +{ // total size: 0x190 public: class RwObjectHasFrame object; // offset 0x0, size 0x14 enum RwCameraProjection projectionType; // offset 0x14, size 0x4 - class RwCamera * (* beginUpdate)(class RwCamera *); // offset 0x18, size 0x4 - class RwCamera * (* endUpdate)(class RwCamera *); // offset 0x1C, size 0x4 + class RwCamera* (*beginUpdate)(class RwCamera*); // offset 0x18, size 0x4 + class RwCamera* (*endUpdate)(class RwCamera*); // offset 0x1C, size 0x4 class RwMatrixTag viewMatrix; // offset 0x20, size 0x40 - class RwRaster * frameBuffer; // offset 0x60, size 0x4 - class RwRaster * zBuffer; // offset 0x64, size 0x4 + class RwRaster* frameBuffer; // offset 0x60, size 0x4 + class RwRaster* zBuffer; // offset 0x64, size 0x4 class RwV2d viewWindow; // offset 0x68, size 0x8 class RwV2d recipViewWindow; // offset 0x70, size 0x8 class RwV2d viewOffset; // offset 0x78, size 0x8 @@ -1354,23 +1467,27 @@ class RwCamera { class RwBBox frustumBoundBox; // offset 0x10C, size 0x18 class RwV3d frustumCorners[8]; // offset 0x124, size 0x60 }; -class _tagEmitLine { +class _tagEmitLine +{ // total size: 0x1C public: class xVec3 pos1; // offset 0x0, size 0xC class xVec3 pos2; // offset 0xC, size 0xC float radius; // offset 0x18, size 0x4 }; -class xParSysInfo { +class xParSysInfo +{ // total size: 0x8 public: signed int type; // offset 0x0, size 0x4 - void (* func)(void *, class xParGroup *); // offset 0x4, size 0x4 + void (*func)(void*, class xParGroup*); // offset 0x4, size 0x4 }; -class xSurface { +class xSurface +{ // total size: 0x0 }; -class xEnvAsset : public xBaseAsset { +class xEnvAsset : public xBaseAsset +{ // total size: 0x44 public: unsigned int bspAssetID; // offset 0x8, size 0x4 @@ -1389,24 +1506,28 @@ class xEnvAsset : public xBaseAsset { unsigned int bspMapperFXID; // offset 0x3C, size 0x4 float loldHeight; // offset 0x40, size 0x4 }; -class RpTriangle { +class RpTriangle +{ // total size: 0x8 public: unsigned short vertIndex[3]; // offset 0x0, size 0x6 signed short matIndex; // offset 0x6, size 0x2 }; -enum RxNodeDefEditable { +enum RxNodeDefEditable +{ rxNODEDEFCONST = 0, rxNODEDEFEDITABLE = 1, rxNODEDEFEDITABLEFORCEENUMSIZEINT = 2147483647, }; -enum RxClusterValid { +enum RxClusterValid +{ rxCLVALID_NOCHANGE = 0, rxCLVALID_VALID = 1, rxCLVALID_INVALID = 2, rxCLUSTERVALIDFORCEENUMSIZEINT = 2147483647, }; -class xPortalAsset : public xBaseAsset { +class xPortalAsset : public xBaseAsset +{ // total size: 0x18 public: unsigned int assetCameraID; // offset 0x8, size 0x4 @@ -1414,26 +1535,29 @@ class xPortalAsset : public xBaseAsset { float ang; // offset 0x10, size 0x4 unsigned int sceneID; // offset 0x14, size 0x4 }; -class xGridBound { +class xGridBound +{ // total size: 0x14 public: - void * data; // offset 0x0, size 0x4 + void* data; // offset 0x0, size 0x4 unsigned short gx; // offset 0x4, size 0x2 unsigned short gz; // offset 0x6, size 0x2 unsigned char ingrid; // offset 0x8, size 0x1 unsigned char oversize; // offset 0x9, size 0x1 unsigned char deleted; // offset 0xA, size 0x1 unsigned char gpad; // offset 0xB, size 0x1 - class xGridBound * * head; // offset 0xC, size 0x4 - class xGridBound * next; // offset 0x10, size 0x4 + class xGridBound** head; // offset 0xC, size 0x4 + class xGridBound* next; // offset 0x10, size 0x4 }; -class xRot { +class xRot +{ // total size: 0x10 public: class xVec3 axis; // offset 0x0, size 0xC float angle; // offset 0xC, size 0x4 }; -class iFogParams { +class iFogParams +{ // total size: 0x1C public: enum RwFogType type; // offset 0x0, size 0x4 @@ -1442,18 +1566,20 @@ class iFogParams { float density; // offset 0xC, size 0x4 class RwRGBA fogcolor; // offset 0x10, size 0x4 class RwRGBA bgcolor; // offset 0x14, size 0x4 - unsigned char * table; // offset 0x18, size 0x4 + unsigned char* table; // offset 0x18, size 0x4 }; -class _tagxRumble { +class _tagxRumble +{ // total size: 0x10 public: enum _tagRumbleType type; // offset 0x0, size 0x4 float seconds; // offset 0x4, size 0x4 - class _tagxRumble * next; // offset 0x8, size 0x4 + class _tagxRumble* next; // offset 0x8, size 0x4 signed short active; // offset 0xC, size 0x2 unsigned short fxflags; // offset 0xE, size 0x2 }; -class xEntAsset : public xBaseAsset { +class xEntAsset : public xBaseAsset +{ // total size: 0x54 public: unsigned char flags; // offset 0x8, size 0x1 @@ -1473,20 +1599,23 @@ class xEntAsset : public xBaseAsset { unsigned int modelInfoID; // offset 0x4C, size 0x4 unsigned int animListID; // offset 0x50, size 0x4 }; -enum rxEmbeddedPacketState { +enum rxEmbeddedPacketState +{ rxPKST_PACKETLESS = 0, rxPKST_UNUSED = 1, rxPKST_INUSE = 2, rxPKST_PENDING = 3, rxEMBEDDEDPACKETSTATEFORCEENUMSIZEINT = 2147483647, }; -class xSphere { +class xSphere +{ // total size: 0x10 public: class xVec3 center; // offset 0x0, size 0xC float r; // offset 0xC, size 0x4 }; -class xScene { +class xScene +{ // total size: 0x70 public: unsigned int sceneID; // offset 0x0, size 0x4 @@ -1506,81 +1635,90 @@ class xScene { unsigned short num_stats_allocd; // offset 0x24, size 0x2 unsigned short num_dyns_allocd; // offset 0x26, size 0x2 unsigned short num_npcs_allocd; // offset 0x28, size 0x2 - class xEnt * * trigs; // offset 0x2C, size 0x4 - class xEnt * * stats; // offset 0x30, size 0x4 - class xEnt * * dyns; // offset 0x34, size 0x4 - class xEnt * * npcs; // offset 0x38, size 0x4 - class xEnt * * act_ents; // offset 0x3C, size 0x4 - class xEnt * * nact_ents; // offset 0x40, size 0x4 - class xEnv * env; // offset 0x44, size 0x4 + class xEnt** trigs; // offset 0x2C, size 0x4 + class xEnt** stats; // offset 0x30, size 0x4 + class xEnt** dyns; // offset 0x34, size 0x4 + class xEnt** npcs; // offset 0x38, size 0x4 + class xEnt** act_ents; // offset 0x3C, size 0x4 + class xEnt** nact_ents; // offset 0x40, size 0x4 + class xEnv* env; // offset 0x44, size 0x4 class xMemPool mempool; // offset 0x48, size 0x1C - class xBase * (* resolvID)(unsigned int); // offset 0x64, size 0x4 - char * (* base2Name)(class xBase *); // offset 0x68, size 0x4 - char * (* id2Name)(unsigned int); // offset 0x6C, size 0x4 + class xBase* (*resolvID)(unsigned int); // offset 0x64, size 0x4 + char* (*base2Name)(class xBase*); // offset 0x68, size 0x4 + char* (*id2Name)(unsigned int); // offset 0x6C, size 0x4 }; -class xAnimTransitionList { +class xAnimTransitionList +{ // total size: 0x8 public: - class xAnimTransitionList * Next; // offset 0x0, size 0x4 - class xAnimTransition * T; // offset 0x4, size 0x4 + class xAnimTransitionList* Next; // offset 0x0, size 0x4 + class xAnimTransition* T; // offset 0x4, size 0x4 }; -class RpWorld { +class RpWorld +{ // total size: 0x70 public: class RwObject object; // offset 0x0, size 0x8 unsigned int flags; // offset 0x8, size 0x4 enum RpWorldRenderOrder renderOrder; // offset 0xC, size 0x4 class RpMaterialList matList; // offset 0x10, size 0xC - class RpSector * rootSector; // offset 0x1C, size 0x4 + class RpSector* rootSector; // offset 0x1C, size 0x4 signed int numTexCoordSets; // offset 0x20, size 0x4 signed int numClumpsInWorld; // offset 0x24, size 0x4 - class RwLLLink * currentClumpLink; // offset 0x28, size 0x4 + class RwLLLink* currentClumpLink; // offset 0x28, size 0x4 class RwLinkList clumpList; // offset 0x2C, size 0x8 class RwLinkList lightList; // offset 0x34, size 0x8 class RwLinkList directionalLightList; // offset 0x3C, size 0x8 class RwV3d worldOrigin; // offset 0x44, size 0xC class RwBBox boundingBox; // offset 0x50, size 0x18 - class RpWorldSector * (* renderCallBack)(class RpWorldSector *); // offset 0x68, size 0x4 - class RxPipeline * pipeline; // offset 0x6C, size 0x4 + class RpWorldSector* (*renderCallBack)(class RpWorldSector*); // offset 0x68, size 0x4 + class RxPipeline* pipeline; // offset 0x6C, size 0x4 }; -class _tagEmitVolume { +class _tagEmitVolume +{ // total size: 0x4 public: unsigned int emit_volumeID; // offset 0x0, size 0x4 }; -enum RwCameraProjection { +enum RwCameraProjection +{ rwNACAMERAPROJECTION = 0, rwPERSPECTIVE = 1, rwPARALLEL = 2, rwCAMERAPROJECTIONFORCEENUMSIZEINT = 2147483647, }; -enum RxClusterForcePresent { +enum RxClusterForcePresent +{ rxCLALLOWABSENT = 0, rxCLFORCEPRESENT = 1, rxCLUSTERFORCEPRESENTFORCEENUMSIZEINT = 2147483647, }; -class xModelTag { +class xModelTag +{ // total size: 0x20 public: class xVec3 v; // offset 0x0, size 0xC unsigned int matidx; // offset 0xC, size 0x4 float wt[4]; // offset 0x10, size 0x10 }; -class xCylinder { +class xCylinder +{ // total size: 0x14 public: class xVec3 center; // offset 0x0, size 0xC float r; // offset 0xC, size 0x4 float h; // offset 0x10, size 0x4 }; -class xEnv { +class xEnv +{ // total size: 0x50 public: - class iEnv * geom; // offset 0x0, size 0x4 + class iEnv* geom; // offset 0x0, size 0x4 class iEnv ienv; // offset 0x10, size 0x30 - class xLightKit * lightKit; // offset 0x40, size 0x4 + class xLightKit* lightKit; // offset 0x40, size 0x4 }; -class xEntDrive { +class xEntDrive +{ // total size: 0x7C public: unsigned int flags; // offset 0x0, size 0x4 @@ -1590,9 +1728,9 @@ class xEntDrive { float tm; // offset 0x10, size 0x4 float tmr; // offset 0x14, size 0x4 float s; // offset 0x18, size 0x4 - class xEnt * odriver; // offset 0x1C, size 0x4 - class xEnt * driver; // offset 0x20, size 0x4 - class xEnt * driven; // offset 0x24, size 0x4 + class xEnt* odriver; // offset 0x1C, size 0x4 + class xEnt* driver; // offset 0x20, size 0x4 + class xEnt* driven; // offset 0x24, size 0x4 class xVec3 op; // offset 0x28, size 0xC class xVec3 p; // offset 0x34, size 0xC class xVec3 q; // offset 0x40, size 0xC @@ -1600,21 +1738,24 @@ class xEntDrive { class xVec3 dloc; // offset 0x50, size 0xC class tri_data tri; // offset 0x5C, size 0x20 }; -class xBox { +class xBox +{ // total size: 0x18 public: class xVec3 upper; // offset 0x0, size 0xC class xVec3 lower; // offset 0xC, size 0xC }; -class RxClusterDefinition { +class RxClusterDefinition +{ // total size: 0x10 public: - char * name; // offset 0x0, size 0x4 + char* name; // offset 0x0, size 0x4 unsigned int defaultStride; // offset 0x4, size 0x4 unsigned int defaultAttributes; // offset 0x8, size 0x4 - char * attributeSet; // offset 0xC, size 0x4 + char* attributeSet; // offset 0xC, size 0x4 }; -class zJumpParam { +class zJumpParam +{ // total size: 0x10 public: float PeakHeight; // offset 0x0, size 0x4 @@ -1622,13 +1763,15 @@ class zJumpParam { float TimeHold; // offset 0x8, size 0x4 float ImpulseVel; // offset 0xC, size 0x4 }; -enum RpWorldRenderOrder { +enum RpWorldRenderOrder +{ rpWORLDRENDERNARENDERORDER = 0, rpWORLDRENDERFRONT2BACK = 1, rpWORLDRENDERBACK2FRONT = 2, rpWORLDRENDERORDERFORCEENUMSIZEINT = 2147483647, }; -class RpLight { +class RpLight +{ // total size: 0x40 public: class RwObjectHasFrame object; // offset 0x0, size 0x14 @@ -1640,20 +1783,24 @@ class RpLight { unsigned short lightFrame; // offset 0x3C, size 0x2 unsigned short pad; // offset 0x3E, size 0x2 }; -enum _tagPadState { +enum _tagPadState +{ ePad_Disabled = 0, ePad_DisabledError = 1, ePad_Enabled = 2, ePad_Missing = 3, ePad_Total = 4, }; -class xEntBoulder { +class xEntBoulder +{ // total size: 0x0 }; -class zEntHangable { +class zEntHangable +{ // total size: 0x0 }; -class RwFrame { +class RwFrame +{ // total size: 0xB0 public: class RwObject object; // offset 0x0, size 0x8 @@ -1661,30 +1808,32 @@ class RwFrame { class RwMatrixTag modelling; // offset 0x10, size 0x40 class RwMatrixTag ltm; // offset 0x50, size 0x40 class RwLinkList objectList; // offset 0x90, size 0x8 - class RwFrame * child; // offset 0x98, size 0x4 - class RwFrame * next; // offset 0x9C, size 0x4 - class RwFrame * root; // offset 0xA0, size 0x4 + class RwFrame* child; // offset 0x98, size 0x4 + class RwFrame* next; // offset 0x9C, size 0x4 + class RwFrame* root; // offset 0xA0, size 0x4 }; -class RwSphere { +class RwSphere +{ // total size: 0x10 public: class RwV3d center; // offset 0x0, size 0xC float radius; // offset 0xC, size 0x4 }; -class xGlobals { +class xGlobals +{ // total size: 0x700 public: class xCamera camera; // offset 0x0, size 0x330 - class _tagxPad * pad0; // offset 0x330, size 0x4 - class _tagxPad * pad1; // offset 0x334, size 0x4 - class _tagxPad * pad2; // offset 0x338, size 0x4 - class _tagxPad * pad3; // offset 0x33C, size 0x4 + class _tagxPad* pad0; // offset 0x330, size 0x4 + class _tagxPad* pad1; // offset 0x334, size 0x4 + class _tagxPad* pad2; // offset 0x338, size 0x4 + class _tagxPad* pad3; // offset 0x33C, size 0x4 signed int profile; // offset 0x340, size 0x4 char profFunc[6][128]; // offset 0x344, size 0x300 - class xUpdateCullMgr * updateMgr; // offset 0x644, size 0x4 + class xUpdateCullMgr* updateMgr; // offset 0x644, size 0x4 signed int sceneFirst; // offset 0x648, size 0x4 char sceneStart[32]; // offset 0x64C, size 0x20 - class RpWorld * currWorld; // offset 0x66C, size 0x4 + class RpWorld* currWorld; // offset 0x66C, size 0x4 class iFogParams fog; // offset 0x670, size 0x1C class iFogParams fogA; // offset 0x68C, size 0x1C class iFogParams fogB; // offset 0x6A8, size 0x1C @@ -1701,7 +1850,8 @@ class xGlobals { unsigned char dontShowPadMessageDuringLoadingOrCutScene; // offset 0x6F0, size 0x1 unsigned char autoSaveFeature; // offset 0x6F1, size 0x1 }; -class iColor_tag { +class iColor_tag +{ // total size: 0x4 public: unsigned char r; // offset 0x0, size 0x1 @@ -1709,36 +1859,42 @@ class iColor_tag { unsigned char b; // offset 0x2, size 0x1 unsigned char a; // offset 0x3, size 0x1 }; -class _tagEmitOffsetPoint { +class _tagEmitOffsetPoint +{ // total size: 0xC public: class xVec3 offset; // offset 0x0, size 0xC }; -class RpSector { +class RpSector +{ // total size: 0x4 public: signed int type; // offset 0x0, size 0x4 }; -class zPlatform { +class zPlatform +{ // total size: 0x0 }; -class xModelBucket { +class xModelBucket +{ // total size: 0x14 public: - class RpAtomic * Data; // offset 0x0, size 0x4 - class RpAtomic * OriginalData; // offset 0x4, size 0x4 - class xModelInstance * List; // offset 0x8, size 0x4 + class RpAtomic* Data; // offset 0x0, size 0x4 + class RpAtomic* OriginalData; // offset 0x4, size 0x4 + class xModelInstance* List; // offset 0x8, size 0x4 signed int ClipFlags; // offset 0xC, size 0x4 unsigned int PipeFlags; // offset 0x10, size 0x4 }; -class RwTexDictionary { +class RwTexDictionary +{ // total size: 0x18 public: class RwObject object; // offset 0x0, size 0x8 class RwLinkList texturesInDict; // offset 0x8, size 0x8 class RwLLLink lInInstance; // offset 0x10, size 0x8 }; -class _tagxPad { +class _tagxPad +{ // total size: 0x148 public: unsigned char value[22]; // offset 0x0, size 0x16 @@ -1761,19 +1917,22 @@ class _tagxPad { float down_tmr[22]; // offset 0xC0, size 0x58 class analog_data analog[2]; // offset 0x118, size 0x30 }; -class _zPortal : public xBase { +class _zPortal : public xBase +{ // total size: 0x14 public: - class xPortalAsset * passet; // offset 0x10, size 0x4 + class xPortalAsset* passet; // offset 0x10, size 0x4 }; -class RxOutputSpec { +class RxOutputSpec +{ // total size: 0xC public: - char * name; // offset 0x0, size 0x4 - enum RxClusterValid * outputClusters; // offset 0x4, size 0x4 + char* name; // offset 0x0, size 0x4 + enum RxClusterValid* outputClusters; // offset 0x4, size 0x4 enum RxClusterValid allOtherClusters; // offset 0x8, size 0x4 }; -class xEntFrame { +class xEntFrame +{ // total size: 0xF0 public: class xMat4x3 mat; // offset 0x0, size 0x40 @@ -1787,10 +1946,12 @@ class xEntFrame { class xVec3 vel; // offset 0xD4, size 0xC unsigned int mode; // offset 0xE0, size 0x4 }; -class zCutsceneMgr { +class zCutsceneMgr +{ // total size: 0x0 }; -class xEntCollis { +class xEntCollis +{ // total size: 0x5B4 public: unsigned char chk; // offset 0x0, size 0x1 @@ -1805,10 +1966,12 @@ class xEntCollis { unsigned char stat_eidx; // offset 0x9, size 0x1 unsigned char idx; // offset 0xA, size 0x1 class xCollis colls[18]; // offset 0xC, size 0x5A0 - void (* post)(class xEnt *, class xScene *, float, class xEntCollis *); // offset 0x5AC, size 0x4 - unsigned int (* depenq)(class xEnt *, class xEnt *, class xScene *, float, class xCollis *); // offset 0x5B0, size 0x4 + void (*post)(class xEnt*, class xScene*, float, class xEntCollis*); // offset 0x5AC, size 0x4 + unsigned int (*depenq)(class xEnt*, class xEnt*, class xScene*, float, + class xCollis*); // offset 0x5B0, size 0x4 }; -class xMat3x3 { +class xMat3x3 +{ // total size: 0x30 public: class xVec3 right; // offset 0x0, size 0xC @@ -1818,107 +1981,124 @@ class xMat3x3 { class xVec3 at; // offset 0x20, size 0xC unsigned int pad2; // offset 0x2C, size 0x4 }; -class RxClusterRef { +class RxClusterRef +{ // total size: 0xC public: - class RxClusterDefinition * clusterDef; // offset 0x0, size 0x4 + class RxClusterDefinition* clusterDef; // offset 0x0, size 0x4 enum RxClusterForcePresent forcePresent; // offset 0x4, size 0x4 unsigned int reserved; // offset 0x8, size 0x4 }; -class xGroupAsset : public xBaseAsset { +class xGroupAsset : public xBaseAsset +{ // total size: 0xC public: unsigned short itemCount; // offset 0x8, size 0x2 unsigned short groupFlags; // offset 0xA, size 0x2 }; -class _tagPadAnalog { +class _tagPadAnalog +{ // total size: 0x2 public: signed char x; // offset 0x0, size 0x1 signed char y; // offset 0x1, size 0x1 }; -class zAssetPickupTable { +class zAssetPickupTable +{ // total size: 0x0 }; -class RwObject { +class RwObject +{ // total size: 0x8 public: unsigned char type; // offset 0x0, size 0x1 unsigned char subType; // offset 0x1, size 0x1 unsigned char flags; // offset 0x2, size 0x1 unsigned char privateFlags; // offset 0x3, size 0x1 - void * parent; // offset 0x4, size 0x4 + void* parent; // offset 0x4, size 0x4 }; -class RwLLLink { +class RwLLLink +{ // total size: 0x8 public: - class RwLLLink * next; // offset 0x0, size 0x4 - class RwLLLink * prev; // offset 0x4, size 0x4 + class RwLLLink* next; // offset 0x0, size 0x4 + class RwLLLink* prev; // offset 0x4, size 0x4 }; -class RpPTankLockStruct { +class RpPTankLockStruct +{ // total size: 0x8 public: - unsigned char * data; // offset 0x0, size 0x4 + unsigned char* data; // offset 0x0, size 0x4 signed int stride; // offset 0x4, size 0x4 }; -class xShadowSimplePoly { +class xShadowSimplePoly +{ // total size: 0x30 public: class xVec3 vert[3]; // offset 0x0, size 0x24 class xVec3 norm; // offset 0x24, size 0xC }; -class _tagiPad { +class _tagiPad +{ // total size: 0x4 public: signed int port; // offset 0x0, size 0x4 }; -class xPEVCyl { +class xPEVCyl +{ // total size: 0xC public: float height; // offset 0x0, size 0x4 float radius; // offset 0x4, size 0x4 float deflection; // offset 0x8, size 0x4 }; -class RxIoSpec { +class RxIoSpec +{ // total size: 0x14 public: unsigned int numClustersOfInterest; // offset 0x0, size 0x4 - class RxClusterRef * clustersOfInterest; // offset 0x4, size 0x4 - enum RxClusterValidityReq * inputRequirements; // offset 0x8, size 0x4 + class RxClusterRef* clustersOfInterest; // offset 0x4, size 0x4 + enum RxClusterValidityReq* inputRequirements; // offset 0x8, size 0x4 unsigned int numOutputs; // offset 0xC, size 0x4 - class RxOutputSpec * outputs; // offset 0x10, size 0x4 + class RxOutputSpec* outputs; // offset 0x10, size 0x4 }; -class xFFX { +class xFFX +{ // total size: 0x0 }; -class tri_data : public tri_data { +class tri_data : public tri_data +{ // total size: 0x20 public: class xVec3 loc; // offset 0xC, size 0xC float yaw; // offset 0x18, size 0x4 - class xCollis * coll; // offset 0x1C, size 0x4 + class xCollis* coll; // offset 0x1C, size 0x4 }; -class /* @class */ { +class /* @class */ +{ // total size: 0xC public: - unsigned char * data; // offset 0x0, size 0x4 + unsigned char* data; // offset 0x0, size 0x4 signed int stride; // offset 0x4, size 0x4 unsigned int size; // offset 0x8, size 0x4 }; -class xCollis { +class xCollis +{ // total size: 0x50 public: unsigned int flags; // offset 0x0, size 0x4 unsigned int oid; // offset 0x4, size 0x4 - void * optr; // offset 0x8, size 0x4 - class xModelInstance * mptr; // offset 0xC, size 0x4 + void* optr; // offset 0x8, size 0x4 + class xModelInstance* mptr; // offset 0xC, size 0x4 float dist; // offset 0x10, size 0x4 class xVec3 norm; // offset 0x14, size 0xC class xVec3 tohit; // offset 0x20, size 0xC class xVec3 depen; // offset 0x2C, size 0xC class xVec3 hdng; // offset 0x38, size 0xC - union { // inferred - class /* @class */ { + union + { // inferred + class /* @class */ + { // total size: 0xC public: float t; // offset 0x0, size 0x4 @@ -1928,24 +2108,30 @@ class xCollis { class tri_data tri; // offset 0x44, size 0xC }; }; -class RxNodeMethods { +class RxNodeMethods +{ // total size: 0x1C public: - signed int (* nodeBody)(class RxPipelineNode *, class RxPipelineNodeParam *); // offset 0x0, size 0x4 - signed int (* nodeInit)(class RxNodeDefinition *); // offset 0x4, size 0x4 - void (* nodeTerm)(class RxNodeDefinition *); // offset 0x8, size 0x4 - signed int (* pipelineNodeInit)(class RxPipelineNode *); // offset 0xC, size 0x4 - void (* pipelineNodeTerm)(class RxPipelineNode *); // offset 0x10, size 0x4 - signed int (* pipelineNodeConfig)(class RxPipelineNode *, class RxPipeline *); // offset 0x14, size 0x4 - unsigned int (* configMsgHandler)(class RxPipelineNode *, unsigned int, unsigned int, void *); // offset 0x18, size 0x4 -}; -class xClumpCollBSPVertInfo { + signed int (*nodeBody)(class RxPipelineNode*, + class RxPipelineNodeParam*); // offset 0x0, size 0x4 + signed int (*nodeInit)(class RxNodeDefinition*); // offset 0x4, size 0x4 + void (*nodeTerm)(class RxNodeDefinition*); // offset 0x8, size 0x4 + signed int (*pipelineNodeInit)(class RxPipelineNode*); // offset 0xC, size 0x4 + void (*pipelineNodeTerm)(class RxPipelineNode*); // offset 0x10, size 0x4 + signed int (*pipelineNodeConfig)(class RxPipelineNode*, + class RxPipeline*); // offset 0x14, size 0x4 + unsigned int (*configMsgHandler)(class RxPipelineNode*, unsigned int, unsigned int, + void*); // offset 0x18, size 0x4 +}; +class xClumpCollBSPVertInfo +{ // total size: 0x4 public: unsigned short atomIndex; // offset 0x0, size 0x2 unsigned short meshVertIndex; // offset 0x2, size 0x2 }; -class RwFrustumPlane { +class RwFrustumPlane +{ // total size: 0x14 public: class RwPlane plane; // offset 0x0, size 0x10 @@ -1954,28 +2140,33 @@ class RwFrustumPlane { unsigned char closestZ; // offset 0x12, size 0x1 unsigned char pad; // offset 0x13, size 0x1 }; -class RwPlane { +class RwPlane +{ // total size: 0x10 public: class RwV3d normal; // offset 0x0, size 0xC float distance; // offset 0xC, size 0x4 }; -class xClumpCollBSPTriangle { +class xClumpCollBSPTriangle +{ // total size: 0x8 public: - class /* @class */ { + class /* @class */ + { // total size: 0x4 public: - union { // inferred + union + { // inferred class xClumpCollBSPVertInfo i; // offset 0x0, size 0x4 - class RwV3d * p; // offset 0x0, size 0x4 + class RwV3d* p; // offset 0x0, size 0x4 }; } v; // offset 0x0, size 0x4 unsigned char flags; // offset 0x4, size 0x1 unsigned char platData; // offset 0x5, size 0x1 unsigned short matIndex; // offset 0x6, size 0x2 }; -class xQCData { +class xQCData +{ // total size: 0x20 public: signed char xmin; // offset 0x0, size 0x1 @@ -1989,7 +2180,8 @@ class xQCData { class xVec3 min; // offset 0x8, size 0xC class xVec3 max; // offset 0x14, size 0xC }; -class xPEEntBone { +class xPEEntBone +{ // total size: 0x18 public: unsigned char flags; // offset 0x0, size 0x1 @@ -2000,48 +2192,54 @@ class xPEEntBone { float radius; // offset 0x10, size 0x4 float deflection; // offset 0x14, size 0x4 }; -class RxCluster { +class RxCluster +{ // total size: 0x1C public: unsigned short flags; // offset 0x0, size 0x2 unsigned short stride; // offset 0x2, size 0x2 - void * data; // offset 0x4, size 0x4 - void * currentData; // offset 0x8, size 0x4 + void* data; // offset 0x4, size 0x4 + void* currentData; // offset 0x8, size 0x4 unsigned int numAlloced; // offset 0xC, size 0x4 unsigned int numUsed; // offset 0x10, size 0x4 - class RxPipelineCluster * clusterRef; // offset 0x14, size 0x4 + class RxPipelineCluster* clusterRef; // offset 0x14, size 0x4 unsigned int attributes; // offset 0x18, size 0x4 }; -class xAnimMultiFileEntry { +class xAnimMultiFileEntry +{ // total size: 0x8 public: unsigned int ID; // offset 0x0, size 0x4 - class xAnimFile * File; // offset 0x4, size 0x4 + class xAnimFile* File; // offset 0x4, size 0x4 }; -class tri_data { +class tri_data +{ // total size: 0xC public: unsigned int index; // offset 0x0, size 0x4 float r; // offset 0x4, size 0x4 float d; // offset 0x8, size 0x4 }; -class RxPacket { +class RxPacket +{ // total size: 0x30 public: unsigned short flags; // offset 0x0, size 0x2 unsigned short numClusters; // offset 0x2, size 0x2 - class RxPipeline * pipeline; // offset 0x4, size 0x4 - unsigned int * inputToClusterSlot; // offset 0x8, size 0x4 - unsigned int * slotsContinue; // offset 0xC, size 0x4 - class RxPipelineCluster * * slotClusterRefs; // offset 0x10, size 0x4 + class RxPipeline* pipeline; // offset 0x4, size 0x4 + unsigned int* inputToClusterSlot; // offset 0x8, size 0x4 + unsigned int* slotsContinue; // offset 0xC, size 0x4 + class RxPipelineCluster** slotClusterRefs; // offset 0x10, size 0x4 class RxCluster clusters[1]; // offset 0x14, size 0x1C }; -class /* @class */ { +class /* @class */ +{ // total size: 0x4 public: - class xVec3 * verts; // offset 0x0, size 0x4 + class xVec3* verts; // offset 0x0, size 0x4 }; -class zLasso { +class zLasso +{ // total size: 0xFC public: unsigned int flags; // offset 0x0, size 0x4 @@ -2068,25 +2266,28 @@ class zLasso { unsigned char reindex[5]; // offset 0xC4, size 0x5 class xVec3 anchor; // offset 0xCC, size 0xC class xModelTag tag; // offset 0xD8, size 0x20 - class xModelInstance * model; // offset 0xF8, size 0x4 + class xModelInstance* model; // offset 0xF8, size 0x4 }; -class zGlobals : public xGlobals { +class zGlobals : public xGlobals +{ // total size: 0x2050 public: class zPlayerGlobals player; // offset 0x700, size 0x1940 - class zAssetPickupTable * pickupTable; // offset 0x2040, size 0x4 - class zCutsceneMgr * cmgr; // offset 0x2044, size 0x4 - class zScene * sceneCur; // offset 0x2048, size 0x4 - class zScene * scenePreload; // offset 0x204C, size 0x4 + class zAssetPickupTable* pickupTable; // offset 0x2040, size 0x4 + class zCutsceneMgr* cmgr; // offset 0x2044, size 0x4 + class zScene* sceneCur; // offset 0x2048, size 0x4 + class zScene* scenePreload; // offset 0x204C, size 0x4 }; -enum RwFogType { +enum RwFogType +{ rwFOGTYPENAFOGTYPE = 0, rwFOGTYPELINEAR = 1, rwFOGTYPEEXPONENTIAL = 2, rwFOGTYPEEXPONENTIAL2 = 3, rwFOGTYPEFORCEENUMSIZEINT = 2147483647, }; -class zGlobalSettings { +class zGlobalSettings +{ // total size: 0x150 public: unsigned short AnalogMin; // offset 0x0, size 0x2 @@ -2176,7 +2377,8 @@ class zGlobalSettings { unsigned char PowerUp[2]; // offset 0x149, size 0x2 unsigned char InitialPowerUp[2]; // offset 0x14B, size 0x2 }; -class RwRGBAReal { +class RwRGBAReal +{ // total size: 0x10 public: float red; // offset 0x0, size 0x4 @@ -2184,14 +2386,16 @@ class RwRGBAReal { float blue; // offset 0x8, size 0x4 float alpha; // offset 0xC, size 0x4 }; -class RwObjectHasFrame { +class RwObjectHasFrame +{ // total size: 0x14 public: class RwObject object; // offset 0x0, size 0x8 class RwLLLink lFrame; // offset 0x8, size 0x8 - class RwObjectHasFrame * (* sync)(class RwObjectHasFrame *); // offset 0x10, size 0x4 + class RwObjectHasFrame* (*sync)(class RwObjectHasFrame*); // offset 0x10, size 0x4 }; -class RpInterpolator { +class RpInterpolator +{ // total size: 0x14 public: signed int flags; // offset 0x0, size 0x4 @@ -2201,44 +2405,50 @@ class RpInterpolator { float recipTime; // offset 0xC, size 0x4 float position; // offset 0x10, size 0x4 }; -class xPECircle { +class xPECircle +{ // total size: 0x14 public: float radius; // offset 0x0, size 0x4 float deflection; // offset 0x4, size 0x4 class xVec3 dir; // offset 0x8, size 0xC }; -class RwLinkList { +class RwLinkList +{ // total size: 0x8 public: class RwLLLink link; // offset 0x0, size 0x8 }; -class xAnimMultiFileBase { +class xAnimMultiFileBase +{ // total size: 0x4 public: unsigned int Count; // offset 0x0, size 0x4 }; -class zPlayerLassoInfo { +class zPlayerLassoInfo +{ // total size: 0x120 public: - class xEnt * target; // offset 0x0, size 0x4 + class xEnt* target; // offset 0x0, size 0x4 float dist; // offset 0x4, size 0x4 unsigned char destroy; // offset 0x8, size 0x1 unsigned char targetGuide; // offset 0x9, size 0x1 float lassoRot; // offset 0xC, size 0x4 - class xEnt * swingTarget; // offset 0x10, size 0x4 - class xEnt * releasedSwing; // offset 0x14, size 0x4 + class xEnt* swingTarget; // offset 0x10, size 0x4 + class xEnt* releasedSwing; // offset 0x14, size 0x4 float copterTime; // offset 0x18, size 0x4 signed int canCopter; // offset 0x1C, size 0x4 class zLasso lasso; // offset 0x20, size 0xFC - class xAnimState * zeroAnim; // offset 0x11C, size 0x4 + class xAnimState* zeroAnim; // offset 0x11C, size 0x4 }; -class /* @class */ { +class /* @class */ +{ // total size: 0x4 public: - union { // inferred + union + { // inferred class xClumpCollBSPVertInfo i; // offset 0x0, size 0x4 - class RwV3d * p; // offset 0x0, size 0x4 + class RwV3d* p; // offset 0x0, size 0x4 }; }; @@ -2249,12 +2459,13 @@ class /* @class */ { Code range: 0x002FBA10 -> 0x002FBACC */ // Range: 0x2FBA10 -> 0x2FBACC -void xParSysRender(class xBase * b /* r2 */) { +void xParSysRender(class xBase* b /* r2 */) +{ // Blocks /* anonymous block */ { // Range: 0x2FBA10 -> 0x2FBACC - class xParGroup * g; // r17 - class xParSys * s; // r16 + class xParGroup* g; // r17 + class xParSys* s; // r16 } } @@ -2265,13 +2476,15 @@ void xParSysRender(class xBase * b /* r2 */) { Code range: 0x002FBAD0 -> 0x002FBBAC */ // Range: 0x2FBAD0 -> 0x2FBBAC -static void xParGroupUpdateR(class xParSys * s /* r19 */, class xParGroup * g /* r18 */, float dt /* r20 */) { +static void xParGroupUpdateR(class xParSys* s /* r19 */, class xParGroup* g /* r18 */, + float dt /* r20 */) +{ // Blocks /* anonymous block */ { // Range: 0x2FBAD0 -> 0x2FBBAC unsigned int i; // r17 - class xParCmd * cmd; // r20 - void (* func)(class xParCmd *, class xParGroup *, float); // r2 + class xParCmd* cmd; // r20 + void (*func)(class xParCmd*, class xParGroup*, float); // r2 } } @@ -2282,13 +2495,14 @@ static void xParGroupUpdateR(class xParSys * s /* r19 */, class xParGroup * g /* Code range: 0x002FBBB0 -> 0x002FBE00 */ // Range: 0x2FBBB0 -> 0x2FBE00 -void xParSysUpdate(class xBase * to /* r2 */, float dt /* r20 */) { +void xParSysUpdate(class xBase* to /* r2 */, float dt /* r20 */) +{ // Blocks /* anonymous block */ { // Range: 0x2FBBB0 -> 0x2FBE00 - class xParSys * s; // r20 - class xParSys * parent; // r19 - class xParGroup * g; // r18 + class xParSys* s; // r20 + class xParSys* parent; // r19 + class xParGroup* g; // r18 } } @@ -2299,11 +2513,12 @@ void xParSysUpdate(class xBase * to /* r2 */, float dt /* r20 */) { Code range: 0x002FBE00 -> 0x002FBF5C */ // Range: 0x2FBE00 -> 0x2FBF5C -signed int xParSysEventCB(class xBase * to /* r2 */, unsigned int toEvent /* r2 */) { +signed int xParSysEventCB(class xBase* to /* r2 */, unsigned int toEvent /* r2 */) +{ // Blocks /* anonymous block */ { // Range: 0x2FBE00 -> 0x2FBF5C - class xParSys * t; // r16 + class xParSys* t; // r16 } } @@ -2314,7 +2529,8 @@ signed int xParSysEventCB(class xBase * to /* r2 */, unsigned int toEvent /* r2 Code range: 0x002FBF60 -> 0x002FBFA0 */ // Range: 0x2FBF60 -> 0x2FBFA0 -void xParSysExit(class xParSys * t /* r16 */) { +void xParSysExit(class xParSys* t /* r16 */) +{ // Blocks /* anonymous block */ { // Range: 0x2FBF60 -> 0x2FBFA0 @@ -2328,7 +2544,8 @@ void xParSysExit(class xParSys * t /* r16 */) { Code range: 0x002FBFA0 -> 0x002FC004 */ // Range: 0x2FBFA0 -> 0x2FC004 -void xParSysSetup(class xParSys * t /* r16 */) { +void xParSysSetup(class xParSys* t /* r16 */) +{ // Blocks /* anonymous block */ { // Range: 0x2FBFA0 -> 0x2FC004 @@ -2342,13 +2559,14 @@ void xParSysSetup(class xParSys * t /* r16 */) { Code range: 0x002FC010 -> 0x002FC2DC */ // Range: 0x2FC010 -> 0x2FC2DC -void xParSysInit(class xBase * b /* r20 */, class xParSysAsset * tasset /* r19 */) { +void xParSysInit(class xBase* b /* r20 */, class xParSysAsset* tasset /* r19 */) +{ // Blocks /* anonymous block */ { // Range: 0x2FC010 -> 0x2FC2DC - class xParSys * t; // r2 + class xParSys* t; // r2 unsigned int i; // r18 - unsigned char * cmdPtr; // r17 + unsigned char* cmdPtr; // r17 } } @@ -2359,7 +2577,8 @@ void xParSysInit(class xBase * b /* r20 */, class xParSysAsset * tasset /* r19 * Code range: 0x002FC2E0 -> 0x002FC2E8 */ // Range: 0x2FC2E0 -> 0x2FC2E8 -void xParSysInit(void * b /* r2 */, void * tasset /* r2 */) { +void xParSysInit(void* b /* r2 */, void* tasset /* r2 */) +{ // Blocks /* anonymous block */ { // Range: 0x2FC2E0 -> 0x2FC2E8 @@ -2373,7 +2592,8 @@ void xParSysInit(void * b /* r2 */, void * tasset /* r2 */) { Code range: 0x002FC2F0 -> 0x002FC324 */ // Range: 0x2FC2F0 -> 0x2FC324 -static void render_par_sprite(void * data /* r2 */, class xParGroup * ps /* r2 */) { +static void render_par_sprite(void* data /* r2 */, class xParGroup* ps /* r2 */) +{ // Blocks /* anonymous block */ { // Range: 0x2FC2F0 -> 0x2FC324 @@ -2387,7 +2607,8 @@ static void render_par_sprite(void * data /* r2 */, class xParGroup * ps /* r2 * Code range: 0x002FC330 -> 0x002FC95C */ // Range: 0x2FC330 -> 0x2FC95C -static void par_sprite_update(class xParSys & sys /* r2 */, class xParGroup & group /* r2 */) { +static void par_sprite_update(class xParSys& sys /* r2 */, class xParGroup& group /* r2 */) +{ // Blocks /* anonymous block */ { // Range: 0x2FC330 -> 0x2FC95C @@ -2395,11 +2616,10 @@ static void par_sprite_update(class xParSys & sys /* r2 */, class xParGroup & gr class xVec3 offset_right; // r29+0x100 class xVec3 offset_up; // r29+0xF0 class ptank_pool__pos_color_size_uv2 pool; // r29+0x30 - class xParCmdTex * tex; // r17 - class xPar * p; // r16 - class xVec4 * _loc; // r2 + class xParCmdTex* tex; // r17 + class xPar* p; // r16 + class xVec4* _loc; // r2 float par_dist; // r1 - class xVec3 & loc; // r9 + class xVec3& loc; // r9 } } - diff --git a/src/SB/Core/gc/iModel.cpp b/src/SB/Core/gc/iModel.cpp index 30ae5ac10..1401782f5 100644 --- a/src/SB/Core/gc/iModel.cpp +++ b/src/SB/Core/gc/iModel.cpp @@ -1,8 +1,7 @@ #include "iModel.h" #include - - +#include "zAssetTypes.h" RwFrame* GetChildFrameHierarchy(RwFrame* frame, void* data) { @@ -23,45 +22,55 @@ void* GetHierarchy(RpAtomic* frame) { void* unk_0[2]; unk_0[0] = 0; - GetChildFrameHierarchy((RwFrame*)frame, unk_0); + GetChildFrameHierarchy((RwFrame*)frame->object.object.parent, unk_0); return unk_0[0]; } - RpAtomic* iModelFileNew(void* buffer, U32 size) { - RwStream* rwmem; - S32 unk_0 = (S32)buffer; - RwStreamType type; - RwStreamAccessType accessType; - - type = (RwStreamType)3; - accessType = (RwStreamAccessType)1; + RwMemory rwmem; - rwmem = RwStreamOpen(type, accessType, buffer); - return iModelStreamRead(rwmem); + return iModelStreamRead(RwStreamOpen(rwSTREAMMEMORY, rwSTREAMREAD, &buffer)); } void iModelUnload(RpAtomic* userdata) { - RpClump* clump; - RwFrame* frame = 0; - RwFrame* root; + // Not really a hard function. + // Don't know why frame and root exist + RpClump* clump; // r17 + RwFrame* frame; // r16 + RwFrame* root; // r2 - clump = (RpClump*)userdata + 0x3c; - if ((RpClump*)userdata != 0) + clump = userdata->clump; + if (clump->object.parent != 0) { - RwFrameGetRoot((RwFrame*)userdata); - RwFrameDestroyHierarchy(frame); - userdata = 0; - + RwFrameGetRoot((RwFrame*)userdata->object.object.parent); + RwFrameDestroyHierarchy((RwFrame*)clump); + userdata->object.object.parent = 0; } - if (clump != 0) + if (&clump->object != 0) { RpClumpDestroy(clump); } } +static RpAtomic* NextAtomicCallback(RpAtomic* atomic, void* data) +{ + RpAtomic** nextModel; + + if (data == atomic) + { + data = 0; + return (RpAtomic*)data; + } + if (data == 0) + { + return atomic; + } + data = atomic; + return atomic; +} + void iModelCacheAtomic(RpAtomic*) { } diff --git a/src/SB/Core/gc/iParMgr.h b/src/SB/Core/gc/iParMgr.h index 3f2e89afd..e82711aef 100644 --- a/src/SB/Core/gc/iParMgr.h +++ b/src/SB/Core/gc/iParMgr.h @@ -20,7 +20,7 @@ struct tagiRenderInput // total size: 0x80 public: U16* m_index; // offset 0x0, size 0x4 - RxObjSpace3DVertex * m_vertex; // offset 0x4, size 0x4 + RxObjSpace3DVertex* m_vertex; // offset 0x4, size 0x4 F32* m_vertexTZ; // offset 0x8, size 0x4 U32 m_mode; // offset 0xC, size 0x4 S32 m_vertexType; // offset 0x10, size 0x4 @@ -38,8 +38,10 @@ void iParMgrRender(); void iRenderInit(); void iRenderSetCameraViewMatrix(xMat4x3* m); void iRenderFlush(); -void iRenderTrianglesImmediate(S32 vertType, S32 vertTypeSize, void* data, S32 dataSize, U16* index, S32 indexSize); +void iRenderTrianglesImmediate(S32 vertType, S32 vertTypeSize, void* data, S32 dataSize, U16* index, + S32 indexSize); void iParMgrRenderParSys_QuadStreak(void* data, xParGroup* ps); void iParMgrRenderParSys_Flat(void* data, xParGroup* ps); +void iParMgrRenderParSys_Sprite(void* data, xParGroup* ps); #endif diff --git a/src/SB/Core/x/containers.h b/src/SB/Core/x/containers.h index befdffb6f..eabeb8b45 100644 --- a/src/SB/Core/x/containers.h +++ b/src/SB/Core/x/containers.h @@ -41,6 +41,7 @@ template struct static_queue U32 _max_size_mask; T* _buffer; void clear(); + void init(unsigned long); }; template struct fixed_queue diff --git a/src/SB/Core/x/xBehaveMgr.cpp b/src/SB/Core/x/xBehaveMgr.cpp index 653488fff..a489eaca1 100644 --- a/src/SB/Core/x/xBehaveMgr.cpp +++ b/src/SB/Core/x/xBehaveMgr.cpp @@ -5,12 +5,12 @@ #include "xBehaveGoalSimple.h" #include "xutil.h" -extern S32 g_modinit_xBehaveMgr; -extern xBehaveMgr* g_behavmgr; +static S32 g_modinit; +static xBehaveMgr* g_behavmgr; void xBehaveMgr_Startup() { - if (g_modinit_xBehaveMgr++ == 0) + if (g_modinit++ == 0) { g_behavmgr = new ('BMGR', NULL) xBehaveMgr(); g_behavmgr->Startup(0xfa, 0xfa); @@ -19,8 +19,8 @@ void xBehaveMgr_Startup() void xBehaveMgr_Shutdown() { - g_modinit_xBehaveMgr--; - if (g_modinit_xBehaveMgr == 0) + g_modinit--; + if (g_modinit == 0) { if (g_behavmgr != NULL) { @@ -93,6 +93,16 @@ void xBehaveMgr::SceneReset() } } +void xBehaveMgr::Startup(S32 size, S32 tmpAlloc) +{ + goalFactory = new ('BMGR', NULL) xFactory(tmpAlloc); + + RegBuiltIn(); + XOrdInit(&psylist, size, 0); + psypool = (xPsyche*)xMemAlloc(gActiveHeap, size * 0x68, 0); + memset(psypool, 0, size * 0x68); +} + void xPsyche::BrainBegin() { xFactory* factory = xBehaveMgr_GoalFactory(); @@ -208,3 +218,23 @@ void xPsyche::Amnesia(S32 i) } } } + +S32 xPsyche::IndexInStack(S32 gid) const +{ + // This kinda sucks + S32 da_idx; + S32 i; + S32 temp; + S32 temp2; + + da_idx = staktop; + + i = 0; + while ((temp = -1, i <= da_idx && (temp2 = goallist->GetID(), temp = i, gid != temp2))) + { + da_idx = da_idx + 4; + i++; + } + + return da_idx; +} diff --git a/src/SB/Core/x/xBehaviour.h b/src/SB/Core/x/xBehaviour.h index 0db2b7249..49e714b06 100644 --- a/src/SB/Core/x/xBehaviour.h +++ b/src/SB/Core/x/xBehaviour.h @@ -134,6 +134,7 @@ struct xPsyche : RyzMemData gid_safegoal = goalID; } void Amnesia(S32); + S32 IndexInStack(S32) const; void SetNotify(xPSYNote* notice) { cb_notice = notice; diff --git a/src/SB/Core/x/xFX.h b/src/SB/Core/x/xFX.h index 9871382dc..60e50f0ed 100644 --- a/src/SB/Core/x/xFX.h +++ b/src/SB/Core/x/xFX.h @@ -71,6 +71,7 @@ struct xFXRibbon U32 mlife; void init(const char*, const char*); + void init(S32, const char*); void set_texture(const char* name); void set_texture(U32); void set_texture(RwTexture* texture); diff --git a/src/SB/Core/x/xModel.h b/src/SB/Core/x/xModel.h index 9ff8f9dcd..885667b0a 100644 --- a/src/SB/Core/x/xModel.h +++ b/src/SB/Core/x/xModel.h @@ -54,7 +54,7 @@ struct xModelInstance RwMatrix* Mat; // 0x4C // Offset: 0x50 - xVec3 Scale; + xVec3 Scale; // 0x704 in globals U32 modelID; U32 shadowID; RpAtomic* shadowmapAtomic; diff --git a/src/SB/Core/x/xParEmitter.h b/src/SB/Core/x/xParEmitter.h index 7a208a44b..aacadcfbe 100644 --- a/src/SB/Core/x/xParEmitter.h +++ b/src/SB/Core/x/xParEmitter.h @@ -15,6 +15,7 @@ struct xParInterp F32 oofreq; void set(F32, F32, F32, U32); + void set(F32); // Used in zNPCDutchman }; // Size 0x138 diff --git a/src/SB/Core/x/xParSys.cpp b/src/SB/Core/x/xParSys.cpp index f53a8f3d9..af7f5732f 100644 --- a/src/SB/Core/x/xParSys.cpp +++ b/src/SB/Core/x/xParSys.cpp @@ -1,3 +1,50 @@ #include "xParSys.h" #include +#include "zScene.h" + +static xVec3 par_offset_right; +static xVec3 par_offset_up; + +static xParSysInfo sParSysInfo[7]; + +static S32 sBlendTable[11] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; + +static void par_sprite_begin() +{ +} + +static void render_par_sprite(void* data, xParGroup* ps) +{ + if (using_ptank_render((*(xParSysAsset*)&ps->m_culled)) == 0) + { + iParMgrRenderParSys_Sprite(data, ps); + } +} + +void xParCmdTexInit(xParCmdTex* tex) +{ + // TODO: Function either needs casts, or its just float meme + tex->unit_count = tex->rows * tex->cols; + tex->unit_width = (tex->x2 - tex->x1) / (tex->cols - 4503599627370496.0); + tex->unit_height = (tex->y2 - tex->y1) / (tex->rows - 4503599627370496.0); +} + +void xParSysInit(void* b, void* tasset) +{ + xParSysInit((xBase*)b, (xParSysAsset*)tasset); +} + +void xParSysInit(xBase* b, xParSysAsset* tasset) +{ +} + +void xParSysSetup(xParSys* t) +{ + if ((t != 0) && (t->link != 0) && (t->link->param[1])) + { + t->parent = (xParSys*)zSceneFindObject(t->cmd->flag); + } + t->parent = (xParSys*)xSTFindAsset(t->cmd->flag, 0); + t->parent = t->parent; +} diff --git a/src/SB/Core/x/xParSys.h b/src/SB/Core/x/xParSys.h index 2b94a8f31..8e11ff69c 100644 --- a/src/SB/Core/x/xParSys.h +++ b/src/SB/Core/x/xParSys.h @@ -4,6 +4,8 @@ #include "xBase.h" #include "xParCmd.h" #include "xParGroup.h" +#include "iParMgr.h" +#include "xstransvc.h" #include @@ -35,10 +37,21 @@ struct xParSys : xBase RwTexture* txtr_particle; }; +struct xParSysInfo +{ + S32 type; + void (*func)(void*, class xParGroup*); +}; + +void xParCmdTexInit(xParCmdTex* tex); void xParSysInit(void* b, void* tasset); +void xParSysInit(xBase* b, xParSysAsset* tasset); void xParSysSetup(xParSys* t); void xParSysExit(xParSys* t); void xParSysRender(xBase* b); +S32 xParSysEventCB(xBase*, xBase*, U32, F32*, xBase*); void xParSysUpdate(xBase* to, xScene*, F32 dt); +WEAK U8 using_ptank_render(const xParSysAsset&); + #endif diff --git a/src/SB/Game/zNPCTypeDutchman.cpp b/src/SB/Game/zNPCTypeDutchman.cpp index 321bb0747..078904e33 100644 --- a/src/SB/Game/zNPCTypeDutchman.cpp +++ b/src/SB/Game/zNPCTypeDutchman.cpp @@ -1,6 +1,7 @@ #include "xVec3.h" #include "xMath3.h" #include "xDebug.h" +#include "zGlobals.h" #include "zNPCTypeDutchman.h" #include @@ -36,10 +37,6 @@ static U32 dutchman_count; namespace { - void kill_sound(S32 a, U32 b) - { - } - struct sound_property { F32 volume; @@ -164,6 +161,72 @@ namespace void register_tweaks(bool init, xModelAssetParam* ap, U32 apsize, const char*); }; + struct sound_data_type + { + U32 id; + U32 handle; + }; + + struct sound_asset + { + char* name; + U32 priority; + U32 flags; + }; + + class curve_node + { + F32 time; + iColor_tag color; + F32 scale; + }; + + static sound_data_type sound_data[6]; + static sound_asset sound_assets[6]; + static xBinaryCamera boss_cam; + static xFXRibbon eye_scorch[2]; + static curve_node burn_ribbon_curve[7]; + static zParEmitter* plasma_emitter; + static xParEmitterCustomSettings plasma_emitter_settings; + static zParEmitter* spark_emitter; + static xParEmitterCustomSettings spark_emitter_settings; + static zParEmitter* light_emitter; + static xParEmitterCustomSettings light_emitter_settings; + static zParEmitter* eyeglow_emitter[2]; + static zParEmitter* death_emitter; + static zParEmitter* dissolve_emitter; + static zParEmitter* fadeout_emitter; + static zParEmitter* fadein_emitter; + static zParEmitter* flame_emitter[3]; + static xParEmitterCustomSettings flame_emitter_settings; + static zParEmitter* snot_emitter; + static xParEmitterCustomSettings snot_emitter_settings; + static zParEmitter* slime_emitter; + static xParEmitterCustomSettings slime_emitter_settings; + static zParEmitter* hand_trail_emitter; + static zParEmitter* blob_emitter; + + static void init_sound() + { + U32 total; // r11 + + memset(&sound_data, 0, 0x30); + + for (U32 i = 0; i < 6; i++) + { + xStrHash((const char*)&sound_assets[i]); + } + } + + U32 play_sound(S32, const xVec3*, F32) + { + return 0; + } + + void kill_sound(S32 a, U32 b) + { + } + static tweak_group tweak; static void set_volume(S32 which, U32, F32 new_vol) @@ -976,22 +1039,242 @@ xAnimTable* ZNPC_AnimTable_Dutchman() return table; } +void zNPCDutchman::Init(xEntAsset* asset) +{ + // Function is at 60% + // Laser_texture and m both need to be used? + + char* scorch_name[2]; // r29+0x58 + S32 i; // r18 + RwTexture* laser_texture; // r2 + S32 model_index; // r3 + xModelInstance* m = model; // r4 + xFXRibbon* ribbon; + + dutchman_count = dutchman_count + 1; + boss_cam.init(); + zNPCCommon::Init(asset); + flg_move = 1; + ribbon = eye_scorch; + flg_vuln = 1; + + for (i = 0; i < 2; i++) + { + ribbon->init((S32)eye_scorch, (const char*)0x1ff); + ribbon->set_default_config(); + ribbon->set_curve(ribbon->curve, 0x7); + ribbon->set_texture("fx_streak1"); + ribbon->cfg.life_time = 5.0; + ribbon->refresh_config(); + } + + laser_raster = (RwRaster*)xSTFindAsset((U32)xStrHash("laser_beam_white_blue"), 0x0); + + waves.init(0xf); + slime.slices.init(0x3f); +} + void zNPCDutchman::Setup() { zNPCSubBoss::Setup(); } +void zNPCDutchman::Reset() +{ + // Best I can get it + // xFXRibbon::clear doenst make much sense + zNPCCommon::Reset(); + memset((void*)flag.face_player, 0, 16); + decompose(); + life = 3; + round = 0; + stage = -1; + alpha = 1.0f; + update_round(); + face_player(); + flg_vuln = 1; + reset_speed(); + move.vel = 0.0f; + move.dest = get_center(); + flag.move = MOVE_FOLLOW; + flames.imax_dist = 1.0f / tweak.ground_radius; + reset_blob_mat(); + waves.clear(); + slime.slices.clear(); + //eye_scorch->joints.clear(); + //eye_scorch->joints.clear(); + fade.sound_handle = 0; + vanish(); + refresh_reticle(); + flag.fighting = 0; + plasma_emitter = zParEmitterFind("PAREMIT_DUTCHMAN_PLASMA"); + plasma_emitter_settings.custom_flags = 0x100; + plasma_emitter_settings.pos = g_O3; + spark_emitter = zParEmitterFind("PAREMIT_DUTCHMAN_SPARKS"); + spark_emitter_settings.custom_flags = 0x100; + spark_emitter_settings.pos = g_O3; + light_emitter = zParEmitterFind("PAREMIT_DUTCHMAN_LIGHT"); + light_emitter_settings.custom_flags = 0x110; + light_emitter_settings.pos = g_O3; + light_emitter->prop->life.set((119.99999f * tweak.beam.light_rate)); + eyeglow_emitter[0] = zParEmitterFind("PAREMIT_DUTCHMAN_EYEGLOW0"); + eyeglow_emitter[1] = zParEmitterFind("PAREMIT_DUTCHMAN_EYEGLOW1"); + death_emitter = zParEmitterFind("PAREMIT_DUTCHMAN_DEATH"); + dissolve_emitter = zParEmitterFind("PAREMIT_DUTCHMAN_DISSOLVE"); + fadeout_emitter = zParEmitterFind("PAREMIT_DUTCHMAN_FADEOUT"); + fadein_emitter = zParEmitterFind("PAREMIT_DUTCHMAN_FADEIN"); + flame_emitter[0] = zParEmitterFind("PAREMIT_DUTCHMAN_FLAME_LIGHT"); + flame_emitter[1] = zParEmitterFind("PAREMIT_DUTCHMAN_FLAME_NORMAL"); + flame_emitter[2] = zParEmitterFind("PAREMIT_DUTCHMAN_FLAME_SPRAY"); + flame_emitter_settings.custom_flags = 0x110; + flame_emitter_settings.pos = g_O3; + light_emitter->prop->life.set((59.999996f)); + snot_emitter = zParEmitterFind("PAREMIT_DUTCHMAN_FLAME_SNOT"); + snot_emitter_settings.custom_flags = 0x300; + slime_emitter = zParEmitterFind("PAREMIT_DUTCHMAN_SLIME_TRAIL"); + slime_emitter_settings.custom_flags = 0x100; + hand_trail_emitter = zParEmitterFind("PAREMIT_DUTCHMAN_HAND_TRAIL"); + blob_emitter = zParEmitterFind("PAREMIT_DUTCHMAN_BLOB"); + psy_instinct->GoalSet('NGM=', 1); +} + void zNPCDutchman::Destroy() { zNPCCommon::Destroy(); dutchman_count--; } +void zNPCDutchman::Process(xScene* xscn, F32 dt) +{ + xVec3 player_loc; + + if (flag.fighting == 0) + { + zNPCCommon::Process(xscn, dt); + } + else + { + delay = delay + dt; + psy_instinct->Timestep(dt, NULL); + if (flag.fighting == 0) + { + zNPCCommon::Process(xscn, dt); + } + else + { + if (flag.face_player != 0) + { + player_loc = globals.player.ent.model->Scale; + get_center(); + } + update_turn(dt); + update_move(dt); + update_animation(dt); + update_flames(dt); + update_eye_glow(dt); + update_hand_trail(dt); + update_fade(dt); + update_slime(dt); + + if ((check_player_damage() & 0xff) != 0) + { + zEntPlayer_Damage((xBase*)this, 1); + } + update_camera(dt); + refresh_reticle(); + flg_xtrarend = flg_xtrarend | 1; + zNPCCommon::Process(xscn, dt); + } + } +} + +S32 zNPCDutchman::SysEvent(xBase* from, xBase* to, U32 toEvent, const F32* toParam, + xBase* toParamWidget, S32* handled) +{ + // Was going to try this function, but literally can't find 0x1d9 + if (toEvent == 0x1d9) + { + psy_instinct->GoalSet('NGM=', 1); + } + else + { + if ((0x1d8 < toEvent) || (toEvent != 0x1b5)) + { + handled = 0; + return zNPCCommon::SysEvent(from, to, toEvent, toParam, toParamWidget, handled); + } + start_fight(); + } + return 1; +} + void zNPCDutchman::Render() { zNPCDutchman::render_debug(); } +void zNPCDutchman::RenderExtra() +{ + S32 oldzwrite; // r29+0x6C + S32 oldztest; // r29+0x68 + U32 oldsrcblend; // r29+0x64 + U32 olddestblend; // r29+0x60 + U8 oldcmp; // r17 + xModelInstance* m; // r16 + U8 haloing; // r17 + + RwRenderStateGet(rwRENDERSTATEFOGENABLE, (void*)&oldcmp); + RwRenderStateGet(rwRENDERSTATESRCBLEND, (void*)&oldcmp); + RwRenderStateGet(rwRENDERSTATEDESTBLEND, (void*)&oldcmp); + RwRenderStateGet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)&oldcmp); + RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)&oldcmp); + RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)&oldcmp); + RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)&oldcmp); + RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)&oldcmp); + iDrawSetFBMSK(-1); + + for (m = model; m != 0; m = m) + { + xModelRenderSingle(m); + } + + iDrawSetFBMSK(0); + + for (m = model; m != 0; m = m) + { + xModelRenderSingle(m); + } + + oldcmp = FALSE; + + if (flag.beaming != 0) + { + if (beam->segments != 0) + { + oldcmp = TRUE; + } + render_beam(); + // if (*(int*)(this + 0x430) + *(int*)(this + 0x54c) != 0) + // { + // bVar1 = true; + // } + } + // 0x2c0 + oldzwrite = flag.fade; + if (oldcmp) + { + render_beam(); + } + if ((2U - oldzwrite | oldzwrite - 2U) < 0) + { + render_halo(); + } + RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)&oldcmp); + RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)&oldcmp); + RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)&oldcmp); + RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)&oldcmp); +} + void zNPCDutchman::SelfSetup() { xBehaveMgr* bmgr = xBehaveMgr_GetSelf(); @@ -1110,6 +1393,19 @@ void zNPCDutchman::update_round() stage = -1; } +void zNPCDutchman::decompose() +{ + if (flag.fighting != 0) + { + flag.fighting = 0; + disable_emitter(*dissolve_emitter); + disable_emitter(*fadein_emitter); + disable_emitter(*fadeout_emitter); + zCameraEnableTracking(CO_BOSS); + boss_cam.stop; + } +} + void zNPCDutchman::render_debug() { } @@ -1151,6 +1447,42 @@ void zNPCDutchman::stop_hand_trail() flag.hand_trail = false; } +void zNPCDutchman::dissolve(F32 delay) +{ + F32 volume; + if (delay == 0.0f) + { + flag.fade = FADE_TELEPORT; + disable_emitter(*fadeout_emitter); + set_alpha(0.0f); + vanish(); + volume = 1.0f; + } + else + { + flag.fade = FADE_DISSOLVE; + fade.time = 0.0f; + fade.duration = delay; + fade.iduration = 1.0f / fade.duration; + enable_emitter(*fadeout_emitter); + set_alpha(1.0f); + reappear(); + volume = 0.0f; + } + enable_emitter(*dissolve_emitter); + start_eye_glow(); + start_hand_trail(); + + if (fade.sound_handle == 0) + { + fade.sound_handle = play_sound(2, (const xVec3*)&bound.pad[3], volume); + } + else + { + set_volume(2, 0, 0.0f); + } +} + void zNPCDutchman::reset_lasso_anim() { xAnimPlaySetState(0, lassdata->holdGuideAnim, 0); diff --git a/src/SB/Game/zNPCTypeDutchman.h b/src/SB/Game/zNPCTypeDutchman.h index c96a1a964..a2de6e5ae 100644 --- a/src/SB/Game/zNPCTypeDutchman.h +++ b/src/SB/Game/zNPCTypeDutchman.h @@ -7,6 +7,9 @@ #include "xBehaviour.h" #include "zNPCTypeCommon.h" #include "zNPCGoals.h" +#include "xCamera.h" +#include "zCamera.h" +#include "xMath3.h" namespace auto_tweak { @@ -169,26 +172,45 @@ struct zNPCDutchman : zNPCSubBoss RwRaster* laser_raster; zNPCDutchman(S32 myType); + void Init(xEntAsset* asset); void Setup(); + void Reset(); void Destroy(); + void Process(xScene*, F32); + S32 SysEvent(xBase* from, xBase* to, U32 toEvent, const F32* toParam, xBase* toParamWidget, + S32* handled); void Render(); + void RenderExtra(); void SelfSetup(); void render_debug(); - void update_animation(float); + void update_turn(F32); + void update_move(F32); + void update_animation(F32); + void update_camera(F32); void kill_wave(zNPCDutchman::wave_data&); - void add_splash(const xVec3&, float); + void add_splash(const xVec3&, F32); void vanish(); void reappear(); void turn_to_face(const xVec3&); void face_player(); + void update_flames(F32); + void start_fight(); + void set_life(S32); void start_beam(); void stop_beam(); + void set_alpha(F32); void start_flames(); void stop_flames(); + U8 check_player_damage(); void get_hand_loc(S32) const; void start_hand_trail(); void stop_hand_trail(); + void refresh_reticle(); + void update_hand_trail(F32); + void dissolve(F32); void reset_lasso_anim(); + void update_fade(F32); + void update_slime(F32); void reset_speed(); void Damage(en_NPC_DAMAGE_TYPE, xBase*, const xVec3*); U32 AnimPick(S32 rawgoal, en_NPC_GOAL_SPOT gspot, xGoal* goal); @@ -200,7 +222,15 @@ struct zNPCDutchman : zNPCSubBoss void goal_delay(); void start_eye_glow(); void stop_eye_glow(); + void update_eye_glow(F32); void get_orbit() const; //Weak + xVec3 get_center() const; //Weak + void reset_blob_mat(); + void render_beam(); + void render_halo(); + + void enable_emitter(zParEmitter&) const; + void disable_emitter(zParEmitter&) const; U8 PhysicsFlags() const; U8 ColPenByFlags() const; U8 ColChkByFlags() const; From 33ba5f1abe9c054048972111742f418028d1d7be Mon Sep 17 00:00:00 2001 From: Colin Miller Date: Fri, 19 Sep 2025 11:04:36 -0400 Subject: [PATCH 10/13] Review Fixes --- config/GQPE78/config.yml | 1 - src/SB/Core/gc/iModel.cpp | 6 +++--- src/SB/Core/x/xFX.cpp | 14 +++++++------- src/SB/Core/x/xParSys.cpp | 7 +++---- src/SB/Core/x/xParSys.h | 2 +- src/SB/Game/zEntPlayer.cpp | 8 ++++---- src/SB/Game/zMain.cpp | 2 +- src/SB/Game/zNPCMessenger.cpp | 2 +- src/SB/Game/zNPCTypeDutchman.cpp | 26 +++++++++++++------------- src/SB/Game/zNPCTypeKingJelly.cpp | 13 ++++++------- 10 files changed, 39 insertions(+), 42 deletions(-) diff --git a/config/GQPE78/config.yml b/config/GQPE78/config.yml index a3da22131..993bb7879 100644 --- a/config/GQPE78/config.yml +++ b/config/GQPE78/config.yml @@ -6,4 +6,3 @@ splits: config/GQPE78/splits.txt symbols_known: true fill_gaps: false ldscript_template: config/GQPE78/ldscript.tpl -write_asm: true diff --git a/src/SB/Core/gc/iModel.cpp b/src/SB/Core/gc/iModel.cpp index 1401782f5..34de7e50a 100644 --- a/src/SB/Core/gc/iModel.cpp +++ b/src/SB/Core/gc/iModel.cpp @@ -37,9 +37,9 @@ void iModelUnload(RpAtomic* userdata) { // Not really a hard function. // Don't know why frame and root exist - RpClump* clump; // r17 - RwFrame* frame; // r16 - RwFrame* root; // r2 + RpClump* clump; + RwFrame* frame; + RwFrame* root; clump = userdata->clump; if (clump->object.parent != 0) diff --git a/src/SB/Core/x/xFX.cpp b/src/SB/Core/x/xFX.cpp index ebff65660..c35df84ab 100644 --- a/src/SB/Core/x/xFX.cpp +++ b/src/SB/Core/x/xFX.cpp @@ -372,9 +372,9 @@ static RpAtomic* AtomicSetShininess(RpAtomic* atomic, void* data) static RpAtomic* AtomicSetEnvMap(RpAtomic* atomic, void* data) { RpMatFXAtomicEnableEffects(atomic); - if ((atomic->geometry) != 0) + if (atomic->geometry != 0) { - RpGeometryForAllMaterials((atomic->geometry), MaterialSetEnvMap2, data); + RpGeometryForAllMaterials(atomic->geometry, MaterialSetEnvMap2, data); } return atomic; } @@ -685,8 +685,8 @@ void xFXAuraRender() // Honestly the closest I can get this function. // fogstate is in the dwarf but currently isn't used in the function. - S32 fogstate; // r29+0x3C - _xFXAura* ap; // r17 + S32 fogstate; + _xFXAura* ap; _xFXAuraAngle* auraAng; if (gAuraTex != NULL) @@ -1076,9 +1076,9 @@ RpAtomic* xFXBubbleRender(RpAtomic* atomic) void xFXRibbonRender() { - xFXRibbon* prev; // r19 - U32 i; // r18 - xFXRibbon* ribbon; // r17 + xFXRibbon* prev; + U32 i; + xFXRibbon* ribbon; RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)0x0); RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)0x1); diff --git a/src/SB/Core/x/xParSys.cpp b/src/SB/Core/x/xParSys.cpp index af7f5732f..5c106bec9 100644 --- a/src/SB/Core/x/xParSys.cpp +++ b/src/SB/Core/x/xParSys.cpp @@ -24,10 +24,9 @@ static void render_par_sprite(void* data, xParGroup* ps) void xParCmdTexInit(xParCmdTex* tex) { - // TODO: Function either needs casts, or its just float meme tex->unit_count = tex->rows * tex->cols; - tex->unit_width = (tex->x2 - tex->x1) / (tex->cols - 4503599627370496.0); - tex->unit_height = (tex->y2 - tex->y1) / (tex->rows - 4503599627370496.0); + tex->unit_width = (tex->x2 - tex->x1) / tex->cols; + tex->unit_height = (tex->y2 - tex->y1) / tex->rows; } void xParSysInit(void* b, void* tasset) @@ -41,7 +40,7 @@ void xParSysInit(xBase* b, xParSysAsset* tasset) void xParSysSetup(xParSys* t) { - if ((t != 0) && (t->link != 0) && (t->link->param[1])) + if (t != 0 && t->link != 0 && t->link->param[1]) { t->parent = (xParSys*)zSceneFindObject(t->cmd->flag); } diff --git a/src/SB/Core/x/xParSys.h b/src/SB/Core/x/xParSys.h index 8e11ff69c..4ee1b7ee7 100644 --- a/src/SB/Core/x/xParSys.h +++ b/src/SB/Core/x/xParSys.h @@ -52,6 +52,6 @@ void xParSysRender(xBase* b); S32 xParSysEventCB(xBase*, xBase*, U32, F32*, xBase*); void xParSysUpdate(xBase* to, xScene*, F32 dt); -WEAK U8 using_ptank_render(const xParSysAsset&); +U8 using_ptank_render(const xParSysAsset&); #endif diff --git a/src/SB/Game/zEntPlayer.cpp b/src/SB/Game/zEntPlayer.cpp index 89a424358..50d60ab82 100644 --- a/src/SB/Game/zEntPlayer.cpp +++ b/src/SB/Game/zEntPlayer.cpp @@ -79,7 +79,7 @@ static S32 sPlayerAttackInAir; #define MAX_DELAYED_SOUNDS 8 static zDelayedStreamSound sDelayedSound[MAX_DELAYED_SOUNDS]; static zPlayerSndTimer sPlayerStreamSndTimer[ePlayerStreamSnd_Total] = {}; -//static PlayerStreakInfo sStreakInfo[3][4] = {}; +static PlayerStreakInfo sStreakInfo[3][4] = {}; F32 startJump; F32 startDouble; @@ -3701,9 +3701,9 @@ void zEntPlayer_Load(xEnt* ent, xSerial* serial) static void zEntPlayer_StreakFX(xEnt* ent, F32) { - S32 i; // r19 - S32 p; // r5 - S32 cp; // r16 + S32 i; + S32 p; + S32 cp; for (S32 i = 0; i < 6; i++) { diff --git a/src/SB/Game/zMain.cpp b/src/SB/Game/zMain.cpp index a27023305..9eff01b5e 100644 --- a/src/SB/Game/zMain.cpp +++ b/src/SB/Game/zMain.cpp @@ -739,7 +739,7 @@ void zMainReadINI() void* buf; U32 size; xIniFile* ini; - uint local_18[2]; + U32 local_18[2]; str = (char*)iFileLoad("SB.INI", 0, (U32*)local_18); if (str = NULL) diff --git a/src/SB/Game/zNPCMessenger.cpp b/src/SB/Game/zNPCMessenger.cpp index 8d80b416f..ad72306f5 100644 --- a/src/SB/Game/zNPCMessenger.cpp +++ b/src/SB/Game/zNPCMessenger.cpp @@ -25,7 +25,7 @@ void zNPCMsg_SceneFinish() return zNPCMsg_SceneReset(); } -void zNPCMsg_SendMsg(en_NPC_MSG_ID msgevent /* r17 */, U32 unk0) +void zNPCMsg_SendMsg(en_NPC_MSG_ID msgevent, U32 unk0) { static NPCMsg msg; memset(&msg, 0, sizeof(NPCMsg)); diff --git a/src/SB/Game/zNPCTypeDutchman.cpp b/src/SB/Game/zNPCTypeDutchman.cpp index 078904e33..0dd9152cd 100644 --- a/src/SB/Game/zNPCTypeDutchman.cpp +++ b/src/SB/Game/zNPCTypeDutchman.cpp @@ -208,7 +208,7 @@ namespace static void init_sound() { - U32 total; // r11 + U32 total; memset(&sound_data, 0, 0x30); @@ -1044,11 +1044,11 @@ void zNPCDutchman::Init(xEntAsset* asset) // Function is at 60% // Laser_texture and m both need to be used? - char* scorch_name[2]; // r29+0x58 - S32 i; // r18 - RwTexture* laser_texture; // r2 - S32 model_index; // r3 - xModelInstance* m = model; // r4 + char* scorch_name[2]; + S32 i; + RwTexture* laser_texture; + S32 model_index; + xModelInstance* m = model; xFXRibbon* ribbon; dutchman_count = dutchman_count + 1; @@ -1215,13 +1215,13 @@ void zNPCDutchman::Render() void zNPCDutchman::RenderExtra() { - S32 oldzwrite; // r29+0x6C - S32 oldztest; // r29+0x68 - U32 oldsrcblend; // r29+0x64 - U32 olddestblend; // r29+0x60 - U8 oldcmp; // r17 - xModelInstance* m; // r16 - U8 haloing; // r17 + S32 oldzwrite; + S32 oldztest; + U32 oldsrcblend; + U32 olddestblend; + U8 oldcmp; + xModelInstance* m; + U8 haloing; RwRenderStateGet(rwRENDERSTATEFOGENABLE, (void*)&oldcmp); RwRenderStateGet(rwRENDERSTATESRCBLEND, (void*)&oldcmp); diff --git a/src/SB/Game/zNPCTypeKingJelly.cpp b/src/SB/Game/zNPCTypeKingJelly.cpp index 2eb1ea54d..be33f2c00 100644 --- a/src/SB/Game/zNPCTypeKingJelly.cpp +++ b/src/SB/Game/zNPCTypeKingJelly.cpp @@ -1322,12 +1322,11 @@ void zNPCKingJelly::BUpdate(xVec3* pos) S32 zNPCKingJelly::SysEvent(xBase* from, xBase* to, U32 toEvent, const F32* toParam, xBase* toParamWidget, S32* handled) { - U32 uVar1; + U32 ret; if (toEvent == 0x1b9) { - LAB_8014808c: - uVar1 = 1; + ret = 1; } else { @@ -1336,19 +1335,19 @@ S32 zNPCKingJelly::SysEvent(xBase* from, xBase* to, U32 toEvent, const F32* toPa if (toEvent == 0x1b5) { start_fight(); - goto LAB_8014808c; + return 1; } } else if (toEvent == 0x1d9) { xPsyche* psy = this->psy_instinct; psy->GoalSet(0x4e474d37, 1); - goto LAB_8014808c; + return 1; } handled = 0; - uVar1 = zNPCCommon::SysEvent(from, to, toEvent, toParam, toParamWidget, handled); + ret = zNPCCommon::SysEvent(from, to, toEvent, toParam, toParamWidget, handled); } - return uVar1; + return ret; } void zNPCKingJelly::RenderExtra() From 4032c3ad9f62c243f957bed6e463d8843a238306 Mon Sep 17 00:00:00 2001 From: Colin Miller Date: Sun, 13 Jul 2025 23:23:56 -0400 Subject: [PATCH 11/13] ported zNPCSupport code, zNPCTypeCommon --- src/SB/Game/zNPCTypeCommon.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/SB/Game/zNPCTypeCommon.h b/src/SB/Game/zNPCTypeCommon.h index 80233c0ce..1ad21c32c 100644 --- a/src/SB/Game/zNPCTypeCommon.h +++ b/src/SB/Game/zNPCTypeCommon.h @@ -10,6 +10,8 @@ #include "xSFX.h" #include "xstransvc.h" #include "xDraw.h" +#include "xstransvc.h" +#include "xDraw.h" #include "zNPCSndTable.h" #include "zMovePoint.h" From f7ee5f278105ead0c90d0466425b5fdce0d68957 Mon Sep 17 00:00:00 2001 From: Colin Miller Date: Mon, 22 Sep 2025 22:49:17 -0400 Subject: [PATCH 12/13] zNPCTypeDutchman --- src/SB/Core/x/xModel.h | 2 + src/SB/Game/zNPCTypeDutchman.cpp | 212 +++++++++++++++++++++++++++++-- src/SB/Game/zNPCTypeDutchman.h | 18 ++- 3 files changed, 216 insertions(+), 16 deletions(-) diff --git a/src/SB/Core/x/xModel.h b/src/SB/Core/x/xModel.h index 885667b0a..9af789f0d 100644 --- a/src/SB/Core/x/xModel.h +++ b/src/SB/Core/x/xModel.h @@ -151,6 +151,8 @@ void xModel_SceneExit(RpWorld* world); xSphere* xModelGetLocalSBound(xModelInstance* model); void xModelGetBoneMat(xMat4x3& mat, const xModelInstance& model, size_t index); void xModelInstanceUpgradeBrotherShared(xModelInstance* inst, U32 flags); +xVec3 xModelGetBoneLocation(const xModelInstance& model, + size_t index); // Based off the usage in zNPCTypeDutchman inline void xModelSetFrame(xModelInstance* modelInst, const xMat4x3* frame) { diff --git a/src/SB/Game/zNPCTypeDutchman.cpp b/src/SB/Game/zNPCTypeDutchman.cpp index 0dd9152cd..d1f8dc3a7 100644 --- a/src/SB/Game/zNPCTypeDutchman.cpp +++ b/src/SB/Game/zNPCTypeDutchman.cpp @@ -34,11 +34,14 @@ static U32 dutchman_count; +extern NPCSndTrax g_sndTrax_Dutchman; + namespace { struct sound_property { + U32 asset; // unknown whether or not this belongs here. Just copied from other structs with same name. Also needed for matching a function F32 volume; F32 range_inner; F32 range_outer; @@ -159,6 +162,7 @@ namespace tweak_callback cb_sound; void register_tweaks(bool init, xModelAssetParam* ap, U32 apsize, const char*); + void load(xModelAssetParam*, U32); }; struct sound_data_type @@ -181,6 +185,7 @@ namespace F32 scale; }; + static delay_goal sequence[3][16]; static sound_data_type sound_data[6]; static sound_asset sound_assets[6]; static xBinaryCamera boss_cam; @@ -229,8 +234,9 @@ namespace static tweak_group tweak; - static void set_volume(S32 which, U32, F32 new_vol) + static void set_volume(S32 which, U32 unk, F32 new_vol) { + xSndSetVol(tweak.sound->asset * unk, new_vol); } void tweak_group::register_tweaks(bool init, xModelAssetParam* ap, U32 apsize, const char*) @@ -1275,6 +1281,16 @@ void zNPCDutchman::RenderExtra() RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)&oldcmp); } +void zNPCDutchman::ParseINI() +{ + zNPCCommon::ParseINI(); + cfg_npc->snd_traxShare = &g_sndTrax_Dutchman; + NPCS_SndTablePrepare(&g_sndTrax_Dutchman); + cfg_npc->snd_trax = &g_sndTrax_Dutchman; + NPCS_SndTablePrepare(&g_sndTrax_Dutchman); + tweak.load(parmdata, pdatsize); +} + void zNPCDutchman::SelfSetup() { xBehaveMgr* bmgr = xBehaveMgr_GetSelf(); @@ -1352,14 +1368,13 @@ U32 zNPCDutchman::AnimPick(S32 rawgoal, en_NPC_GOAL_SPOT gspot, xGoal* goal) void zNPCDutchman::LassoNotify(en_LASSO_EVENT event) { - if ((event != 3) && (event < 3) && (event > 1)) + if ((event != 3) && (event < 3) && (event < 2)) { - // xPsyche::GoalSet(NPC_GOAL_DUTCHMANCAUGHT, 1); + psy_instinct->GoalSet('NGMF', 1); } zNPCCommon::LassoNotify(event); } -//NPC_GOAL_DUTCHMANCAUGHT // double zNPCDutchman::goal_delay() // { @@ -1393,6 +1408,16 @@ void zNPCDutchman::update_round() stage = -1; } +S32 zNPCDutchman::next_goal() +{ + return 0; +} + +F32 zNPCDutchman::goal_delay() +{ + return 0; +} + void zNPCDutchman::decompose() { if (flag.fighting != 0) @@ -1402,7 +1427,7 @@ void zNPCDutchman::decompose() disable_emitter(*fadein_emitter); disable_emitter(*fadeout_emitter); zCameraEnableTracking(CO_BOSS); - boss_cam.stop; + boss_cam.stop(); } } @@ -1410,8 +1435,17 @@ void zNPCDutchman::render_debug() { } -void zNPCDutchman::update_animation(float) +void zNPCDutchman::update_animation(F32) +{ +} + +void zNPCDutchman::update_camera(F32 dt) { + zCameraDisableTracking(CO_BOSS); + if ((zCameraIsTrackingDisabled() & -9) == 0) + { + boss_cam.update(dt); + } } void zNPCDutchman::kill_wave(zNPCDutchman::wave_data& wave) @@ -1450,7 +1484,7 @@ void zNPCDutchman::stop_hand_trail() void zNPCDutchman::dissolve(F32 delay) { F32 volume; - if (delay == 0.0f) + if (delay <= 0.0f) { flag.fade = FADE_TELEPORT; disable_emitter(*fadeout_emitter); @@ -1483,15 +1517,140 @@ void zNPCDutchman::dissolve(F32 delay) } } +void zNPCDutchman::coalesce(F32 delay) +{ + reappear(); + if (delay <= 0.0f) + { + flag.fade = FADE_NONE; + disable_emitter(*fadein_emitter); + disable_emitter(*dissolve_emitter); + set_alpha(1.0f); + stop_eye_glow(); + stop_hand_trail(); + if (fade.sound_handle != 0) + { + kill_sound(2, fade.sound_handle); + fade.sound_handle = 0; + } + } + else + { + flag.fade = FADE_COALESCE; + fade.time = 0.0f; + fade.duration = delay; + fade.iduration = 1.0f / fade.duration; + enable_emitter(*fadein_emitter); + enable_emitter(*dissolve_emitter); + set_alpha(0.0f); + start_eye_glow(); + start_hand_trail(); + if (fade.sound_handle != 0) + { + set_volume(2, fade.sound_handle, 1.0f); + } + } +} + +void zNPCDutchman::reset_blob_mat() +{ + // Decomp.me says 90% + F32 temp; + F32 temp2; + + temp = isin(tweak.flame.blob_pitch); + temp2 = icos(tweak.flame.blob_pitch); + flames.blob_mat.right.assign(1.0f, 0.0f, 0.0f); + flames.blob_mat.up.assign(0.0f, temp2, temp); + flames.blob_mat.at.assign(0.0f, -temp, temp2); +} + void zNPCDutchman::reset_lasso_anim() { xAnimPlaySetState(0, lassdata->holdGuideAnim, 0); } +void zNPCDutchman::update_fade(F32 delay) +{ + F32 frac; + if (flag.fade != FADE_TELEPORT) + { + if (flag.fade < 1) + { + if (flag.fade < 4) + { + fade.time = fade.time + delay; + if (fade.time >= fade.duration) + { + flag.fade = FADE_TELEPORT; + disable_emitter(*fadeout_emitter); + set_alpha(0.0f); + vanish(); + set_volume(2, fade.sound_handle, 1.0f); + } + else + { + frac = fade.time * fade.iduration; + set_alpha(1.0f - frac); + set_volume(2, fade.sound_handle, frac); + } + } + } + else if (flag.fade < 4) + { + fade.time = fade.time + delay; + if (fade.time >= fade.duration) + { + flag.fade = FADE_NONE; + disable_emitter(*fadein_emitter); + disable_emitter(*dissolve_emitter); + set_alpha(1.0f); + stop_eye_glow(); + stop_hand_trail(); + reappear(); + kill_sound(2, fade.sound_handle); + fade.sound_handle = 0; + } + else + { + frac = fade.time * fade.iduration; + set_alpha(frac); + set_volume(2, fade.sound_handle, 1.0f - frac); + } + } + } +} + void zNPCDutchman::add_splash(const xVec3&, float) { } +void zNPCDutchman::start_fight() +{ + if (flag.fighting == 0 && life <= 0) + { + flag.fighting = 1; + psy_instinct->GoalSet(0, 0); + zCameraDisableTracking(CO_BOSS); + boss_cam.start(globals.camera); + boss_cam.set_targets((xVec3&)globals.player.ent.model->Mat->pos, (xVec3&)model->Mat->pos, + 2.0f); + } +} + +void zNPCDutchman::set_life(S32 lf) +{ + life = range_limit(life, 0, 3); + if (life < lf) + { + flag.hurting = 1; + for (S32 i = life; i < life; i++) + { + zEntEvent((xBase*)lf, (xBase*)lf, 0x1d7); // Haven't found 0x1d7. only 0x1d8 and 0x1d4 + } + } +} + void zNPCDutchman::start_beam() { if ((flag.beaming) != 0) @@ -1532,6 +1691,21 @@ void zNPCDutchman::stop_flames() flag.flaming = false; } +void zNPCDutchman::get_eye_loc(S32 idx) const +{ + // Not sure if this is correct. + static size_t lookup; + xModelGetBoneLocation(*model, lookup << 2 + idx); +} + +void zNPCDutchman::get_hand_loc(S32) const +{ +} + +void zNPCDutchman::get_splash_loc() const +{ +} + void zNPCDutchman::vanish() { old.moreFlags = moreFlags; @@ -1555,13 +1729,25 @@ void zNPCDutchman::reset_speed() { } +void zNPCDutchman::render_beam() +{ +} + xFactoryInst* zNPCGoalDutchmanInitiate::create(S32 who, RyzMemGrow* grow, void* info) { return new (who, grow) zNPCGoalDutchmanInitiate(who, (zNPCDutchman&)*info); } +S32 zNPCGoalDutchmanInitiate::Enter(F32 dt, void* updCtxt) +{ + owner.get_orbit(); + owner.face_player(); + return zNPCGoalCommon::Enter(dt, updCtxt); +} + S32 zNPCGoalDutchmanInitiate::Exit(F32 dt, void* updCtxt) { + owner.turn.accel = tweak.turn_accel; return xGoal::Exit(dt, updCtxt); } @@ -1581,12 +1767,12 @@ S32 zNPCGoalDutchmanIdle::Exit(F32 dt, void* updCtxt) return xGoal::Exit(dt, updCtxt); } -S32 zNPCGoalDutchmanIdle::Process(en_trantype* trantype, float dt, void* updCtxt, xScene* xscn) +S32 zNPCGoalDutchmanIdle::Process(en_trantype* trantype, F32 dt, void* updCtxt, xScene* xscn) { - owner.goal_delay(); - if (owner.delay == owner.delay) + F32 tmpFlt = owner.goal_delay(); + if (owner.delay >= tmpFlt) { - owner.delay = 1; + owner.delay = 0; owner.next_goal(); } @@ -1650,6 +1836,10 @@ S32 zNPCGoalDutchmanBeam::Exit(F32 dt, void* updCtxt) return xGoal::Exit(dt, updCtxt); } +void zNPCGoalDutchmanBeam::update_stop(F32 dt) +{ +} + xFactoryInst* zNPCGoalDutchmanFlame::create(S32 who, RyzMemGrow* grow, void* info) { return new (who, grow) zNPCGoalDutchmanFlame(who, (zNPCDutchman&)*info); diff --git a/src/SB/Game/zNPCTypeDutchman.h b/src/SB/Game/zNPCTypeDutchman.h index a2de6e5ae..ef3fd80b6 100644 --- a/src/SB/Game/zNPCTypeDutchman.h +++ b/src/SB/Game/zNPCTypeDutchman.h @@ -124,10 +124,10 @@ struct zNPCDutchman : zNPCSubBoss { xVec2 dir; //0x2d4 F32 vel; //0x2dc - F32 accel; //0x2e0 - F32 max_vel; //0x2e4 + F32 accel; //0x2e4 + F32 max_vel; //0x2e8 } turn; - move_info move; //0x2e8 + move_info move; struct { U8 moreFlags; //0x31c @@ -181,6 +181,7 @@ struct zNPCDutchman : zNPCSubBoss S32* handled); void Render(); void RenderExtra(); + void ParseINI(); void SelfSetup(); void render_debug(); void update_turn(F32); @@ -202,12 +203,15 @@ struct zNPCDutchman : zNPCSubBoss void start_flames(); void stop_flames(); U8 check_player_damage(); + void get_eye_loc(S32) const; void get_hand_loc(S32) const; + void get_splash_loc() const; void start_hand_trail(); void stop_hand_trail(); void refresh_reticle(); void update_hand_trail(F32); void dissolve(F32); + void coalesce(F32); void reset_lasso_anim(); void update_fade(F32); void update_slime(F32); @@ -218,8 +222,8 @@ struct zNPCDutchman : zNPCSubBoss S32 LassoSetup(); void update_round(); void decompose(); - void next_goal(); - void goal_delay(); + S32 next_goal(); + F32 goal_delay(); void start_eye_glow(); void stop_eye_glow(); void update_eye_glow(F32); @@ -231,6 +235,8 @@ struct zNPCDutchman : zNPCSubBoss void enable_emitter(zParEmitter&) const; void disable_emitter(zParEmitter&) const; + void turning() const; // Not sure this is the correct return type + void turning(F32) const; // Not sure this is the correct return type U8 PhysicsFlags() const; U8 ColPenByFlags() const; U8 ColChkByFlags() const; @@ -251,6 +257,7 @@ struct zNPCGoalDutchmanInitiate : zNPCGoalCommon { } + S32 Enter(float, void*); S32 Exit(float, void*); static xFactoryInst* create(S32 who, RyzMemGrow* grow, void* info); @@ -344,6 +351,7 @@ struct zNPCGoalDutchmanBeam : zNPCGoalCommon } S32 Exit(float, void*); + void update_stop(F32 dt); static xFactoryInst* create(S32 who, RyzMemGrow* grow, void* info); }; From ac1cc591e77b386c1749c54beaa5eb8d67e5015c Mon Sep 17 00:00:00 2001 From: Colin Miller Date: Thu, 2 Oct 2025 02:07:39 +0000 Subject: [PATCH 13/13] Fix regression --- src/SB/Game/zNPCTypeDutchman.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/SB/Game/zNPCTypeDutchman.cpp b/src/SB/Game/zNPCTypeDutchman.cpp index d1f8dc3a7..8a049ef2f 100644 --- a/src/SB/Game/zNPCTypeDutchman.cpp +++ b/src/SB/Game/zNPCTypeDutchman.cpp @@ -41,7 +41,6 @@ namespace struct sound_property { - U32 asset; // unknown whether or not this belongs here. Just copied from other structs with same name. Also needed for matching a function F32 volume; F32 range_inner; F32 range_outer; @@ -236,7 +235,7 @@ namespace static void set_volume(S32 which, U32 unk, F32 new_vol) { - xSndSetVol(tweak.sound->asset * unk, new_vol); + xSndSetVol(tweak.sound->volume * unk, new_vol); } void tweak_group::register_tweaks(bool init, xModelAssetParam* ap, U32 apsize, const char*)