From 102ffdac124fc214550439a7c68b06319ad1ed78 Mon Sep 17 00:00:00 2001 From: inspectredc <78732756+inspectredc@users.noreply.github.com> Date: Sat, 14 Feb 2026 16:57:07 +0000 Subject: [PATCH 1/3] Match remaining functions in clocks.c seq.c and graphics.c --- config/us/pilotwings64.us.yaml | 5 +- config/us/sym/symbol_addrs_kernel.txt | 266 +++++------ config/us/sym/symbol_addrs_libultra.txt | 2 - include/libc/stdint.h | 29 ++ include/uv_clocks.h | 4 +- include/uv_dobj.h | 2 +- include/uv_graphics.h | 13 +- src/kernel/clocks.c | 23 +- src/kernel/graphics.c | 561 ++++++++++++++++++++++-- src/kernel/seq.c | 16 +- 10 files changed, 743 insertions(+), 178 deletions(-) create mode 100644 include/libc/stdint.h diff --git a/config/us/pilotwings64.us.yaml b/config/us/pilotwings64.us.yaml index eddbfbf..eccf12d 100644 --- a/config/us/pilotwings64.us.yaml +++ b/config/us/pilotwings64.us.yaml @@ -256,6 +256,7 @@ segments: - [0x464E0, textbin, rspboot] - [0x465B0, textbin, f3dex] + - [0x479E0, textbin, fast3d] - [0x48E10, textbin, aspMain] - [0x49C30, .data, kernel/audio] @@ -333,8 +334,8 @@ segments: - [0x50AD0, .rodata, ultralib/src/audio/env] - [0x50B30, .rodata, ultralib/src/audio/seq] - [0x50B40, .rodata, ultralib/src/audio/reverb] - - [0x50B70, rodata] - - [0x51370, rodata] + - [0x50B70, rodata, f3dex] + - [0x51370, rodata, fast3d] - [0x51B70, rodata] - { type: bss, vram: 0x80250E80, name: kernel_bss } diff --git a/config/us/sym/symbol_addrs_kernel.txt b/config/us/sym/symbol_addrs_kernel.txt index 23a899f..ca6b680 100644 --- a/config/us/sym/symbol_addrs_kernel.txt +++ b/config/us/sym/symbol_addrs_kernel.txt @@ -375,136 +375,148 @@ uvAtan2F = 0x8022A27C; // type:func rspbootTextStart = 0x80245530; // name_end:rspbootTextEnd gspF3DEX_fifoTextStart = 0x80245600; // name_end:gspF3DEX_fifoTextEnd +gspFast3DTextStart = 0x80246A30; // name_end:gspFast3DTextEnd aspMainTextStart = 0x80247E60; // name_end:aspMainTextEnd +gspF3DEX_fifoDataStart = 0x8024FBC0; // name_end:gspF3DEX_fifoDataEnd +gspFast3DDataStart = 0x802503C0; // name_end:gspFast3DDataEnd + // ----------------------------------------------------------------------------- // Data Symbols // ----------------------------------------------------------------------------- -gMatrixStackIdx = 0x8024B250; -gMatrixStack = 0x802B81E0; - -gRandLcgState = 0x8024B2C0; -gRanluxState1 = 0x8024B2C4; -gRanluxState2 = 0x8024B2C8; - -gKernelThread = 0x802C36F8; -gKernelThreadStack = 0x802BDC90; - -gRenderThread = 0x802C3548; -gRenderThreadStack = 0x802BBC90; - -gAppThread = 0x802C3398; -gAppThreadStack = 0x802C1C90; - -gNmiAsserted = 0x802B9C80; - -gPiMgrCmdQ = 0x802C3340; -gPiMgrCmdBuf = 0x802C3320; - -gPiDmaQ = 0x802C32C0; -gPiDmaBuf = 0x802C32BC; -gPiDmaBlockReq = 0x802C32A8; - -gSiContQ = 0x802C32E8; -gSiContBuf = 0x802C32D8; -gSiContStatus = 0x802C3358; -gSiContPattern = 0x802C3394; - -gSchedInst = 0x802C38A8; -gSchedStack = 0x802C5BA8; -gSchedRspStatus = 0x802B9C69; -gSchedRdpStatus = 0x802B9C6A; -gSchedRingIdx = 0x802B9C78; -gSchedMsgQ = 0x802C38E8; - -gGeomVertexData = 0x80290680; -gGeomVertexToggle = 0x80296A84; -gGeomVertexCount = 0x80296A86; -gGeomVertexPtrs = 0x80296A80; -gGeomFirstTmesh = 0x80296A88; -gGeomFirstPoly = 0x80296A8A; -gGeomFirstGrid = 0x80296A8C; - -gGfxUnkPtrs = 0x80248DD0; -gGfxDList1 = 0x80249140; -gGfxDList2 = 0x802491B0; -gGfxFbCurrPtr = 0x802491F0; -gGfxBeginFlag = 0x80249204; -gGfxFbIndex = 0x8024920C; -gGfxMstackIdx = 0x80249218; -gGfxDisplayListHead = 0x80298AB0; -gGfxLookCount = 0x80298AE0; -gGfxStateStackData = 0x80299268; -gGfxFbPtrs = 0x80299270; -gGfxDisplayListBase = 0x80299280; -gGfxViewports = 0x802A9900; -gGfxViewX0 = 0x802A9980; -gGfxViewX1 = 0x802A9982; -gGfxViewY0 = 0x802A9984; -gGfxViewY1 = 0x802A9986; -gGfxMstack = 0x802A9988; -gGfxStateStack = 0x802B48C8; -gGfxStateStackIdx = 0x802B4948; - -gSeqPlayer = 0x80248C90; -gSndPlayer = 0x80248C94; -gSndEmitterTable = 0x80250EF8; -gSndVoiceTable = 0x80261218; - -osViModeTable = 0x8024B7D0; -osViModeNtscLan1 = 0x8024C4A0; -osViModePalLan1 = 0x8024C4F0; - -gUVBlockCounts = 0x802B53C8; -gUVBlockOffsets = 0x802B53F0; - -gControllerPattern = 0x802C5BB4; -gControllerInfo = 0x802B5310; - -gEepromFound = 0x802C5BB0; -gControllerPads = 0x802C3370; - -gSprtUnkIndex = 0x802C64D0; -gSprtUnkTable = 0x802C64D8; -gSprtTable1 = 0x802C7478; // size:0xBA0 - -gLevelData = 0x802C1C98; -gLevelWOBJ = 0x80369F30; -gLevelLPAD = 0x8036A030; -gLevelTPTS = 0x8036A180; -gLevelTOYS = 0x8036A4C0; -gLevelAPTS = 0x8036A5C0; -gLevelBNUS = 0x8036A840; -gLevelObjects = 0x8036A878; - -gLevelClassU8 = 0x80350790; -gLevelVehicleU8 = 0x80350794; -gLevelTestU8 = 0x80350798; -gMapLookup = 0x803507A8; - -gTitleMenuDelay = 0x80356A68; - -gLandingPadCount = 0x8036C2B9; -gLandingStripCount = 0x8036C2BA; -gLandingPads = 0x8036C2E8; // size:0x150 -gLandingStrips = 0x8036C438; // size:0x78 - -gRadarThermCirc = 0x8036C520; // size:0x88 -gHudState = 0x8036C5A8; // size:0xC7C - -gLevelCommObjs = 0x8037A600; // size:0x478 -gLevelClass = 0x8037AA78; -gLevelTest = 0x8037AA7C; -gLevelVehicle = 0x8037AA80; - -gThermalCount = 0x8037AB54; -gThermals = 0x8037AB58; // size:0x180 - -gLevelCurMap = 0x8034F40C; -gLevelObjHeapPtr = 0x8034F840; -gLevelObjHeap = 0x8036AA60; // size:5000 - -sWindObjectsData = 0x8037F910; -sWindObjectsInLevel = 0x8037F914; -sWindObjects = 0x8037F918; +gMatrixStackIdx = 0x8024B250; +gMatrixStack = 0x802B81E0; + +gRandLcgState = 0x8024B2C0; +gRanluxState1 = 0x8024B2C4; +gRanluxState2 = 0x8024B2C8; + +gKernelThread = 0x802C36F8; +gKernelThreadStack = 0x802BDC90; + +gRenderThread = 0x802C3548; +gRenderThreadStack = 0x802BBC90; + +gAppThread = 0x802C3398; +gAppThreadStack = 0x802C1C90; + +gNmiAsserted = 0x802B9C80; + +gPiMgrCmdQ = 0x802C3340; +gPiMgrCmdBuf = 0x802C3320; + +gPiDmaQ = 0x802C32C0; +gPiDmaBuf = 0x802C32BC; +gPiDmaBlockReq = 0x802C32A8; + +gSiContQ = 0x802C32E8; +gSiContBuf = 0x802C32D8; +gSiContStatus = 0x802C3358; +gSiContPattern = 0x802C3394; + +gSchedInst = 0x802C38A8; +gSchedStack = 0x802C5BA8; +gSchedRspStatus = 0x802B9C69; +gSchedRdpStatus = 0x802B9C6A; +gSchedRingIdx = 0x802B9C78; +gSchedMsgQ = 0x802C38E8; + +D_8028B400 = 0x8028B400; // size:0x5280 +gGeomVertexData = 0x80290680; +gGeomVertexToggle = 0x80296A84; +gGeomVertexCount = 0x80296A86; +gGeomVertexPtrs = 0x80296A80; +gGeomFirstTmesh = 0x80296A88; +gGeomFirstPoly = 0x80296A8A; +gGeomFirstGrid = 0x80296A8C; + +gGfxUnkPtrs = 0x80248DD0; +gGfxDList1 = 0x80249140; +gGfxDList2 = 0x802491B0; +gGfxFbCurrPtr = 0x802491F0; +gGfxBeginFlag = 0x80249204; +gGfxFbIndex = 0x8024920C; +gGfxMstackIdx = 0x80249218; +gGfxTaskOutputBufferStart = 0x80298AA8; +gGfxTaskOutputBufferEnd = 0x80298AAC; +gGfxDisplayListHead = 0x80298AB0; +gGfxLookCount = 0x80298AE0; +gGfxStateStackData = 0x80299268; +gGfxFbPtrs = 0x80299270; +gGfxDisplayListBase = 0x80299280; +gGfxViewports = 0x802A9900; +gGfxViewX0 = 0x802A9980; +gGfxViewX1 = 0x802A9982; +gGfxViewY0 = 0x802A9984; +gGfxViewY1 = 0x802A9986; +gGfxMstack = 0x802A9988; +gGfxStateStack = 0x802B48C8; +gGfxStateStackIdx = 0x802B4948; +gGfxYieldData = 0x802B4A00; +gGfxDramStack = 0x802B7DE0; + +gSeqPlayer = 0x80248C90; +gSndPlayer = 0x80248C94; +gSndEmitterTable = 0x80250EF8; +gSndVoiceTable = 0x80261218; + +D_80263780 = 0x80263780; // size:0x1900 +D_80269B80 = 0x80269B80; // size:0x12C + +osViModeTable = 0x8024B7D0; +osViModeNtscLan1 = 0x8024C4A0; +osViModePalLan1 = 0x8024C4F0; + +gUVBlockCounts = 0x802B53C8; +gUVBlockOffsets = 0x802B53F0; + +gControllerPattern = 0x802C5BB4; +gControllerInfo = 0x802B5310; + +gEepromFound = 0x802C5BB0; +gControllerPads = 0x802C3370; + +gSprtUnkIndex = 0x802C64D0; +gSprtUnkTable = 0x802C64D8; +gSprtTable1 = 0x802C7478; // size:0xBA0 + +gLevelData = 0x802C1C98; +gLevelWOBJ = 0x80369F30; +gLevelLPAD = 0x8036A030; +gLevelTPTS = 0x8036A180; +gLevelTOYS = 0x8036A4C0; +gLevelAPTS = 0x8036A5C0; +gLevelBNUS = 0x8036A840; +gLevelObjects = 0x8036A878; + +gLevelClassU8 = 0x80350790; +gLevelVehicleU8 = 0x80350794; +gLevelTestU8 = 0x80350798; +gMapLookup = 0x803507A8; + +gTitleMenuDelay = 0x80356A68; + +gLandingPadCount = 0x8036C2B9; +gLandingStripCount = 0x8036C2BA; +gLandingPads = 0x8036C2E8; // size:0x150 +gLandingStrips = 0x8036C438; // size:0x78 + +gRadarThermCirc = 0x8036C520; // size:0x88 +gHudState = 0x8036C5A8; // size:0xC7C + +gLevelCommObjs = 0x8037A600; // size:0x478 +gLevelClass = 0x8037AA78; +gLevelTest = 0x8037AA7C; +gLevelVehicle = 0x8037AA80; + +gThermalCount = 0x8037AB54; +gThermals = 0x8037AB58; // size:0x180 + +gLevelCurMap = 0x8034F40C; +gLevelObjHeapPtr = 0x8034F840; +gLevelObjHeap = 0x8036AA60; // size:5000 + +sWindObjectsData = 0x8037F910; +sWindObjectsInLevel = 0x8037F914; +sWindObjects = 0x8037F918; diff --git a/config/us/sym/symbol_addrs_libultra.txt b/config/us/sym/symbol_addrs_libultra.txt index 3eb3d4d..e02afe7 100644 --- a/config/us/sym/symbol_addrs_libultra.txt +++ b/config/us/sym/symbol_addrs_libultra.txt @@ -315,9 +315,7 @@ resample_rodata_0030 = 0x8024FB10; env_rodata_0010 = 0x8024FB30; seq_rodata_0000 = 0x8024FB80; seq_rodata_0008 = 0x8024FB88; -osAfterPreNMI = 0x802639AC; MusFxBankSetPtrBank = 0x8026AD0C; -alSynFreeFX = 0x802902E4; sprite_bss_0000 = 0x802C8040; sprite_bss_0004 = 0x802C8044; sprite_bss_0008 = 0x802C8048; diff --git a/include/libc/stdint.h b/include/libc/stdint.h new file mode 100644 index 0000000..854fd25 --- /dev/null +++ b/include/libc/stdint.h @@ -0,0 +1,29 @@ +#ifndef LIBC_STDINT_H +#define LIBC_STDINT_H + +#include "PR/ultratypes.h" + +typedef s32 intptr_t; +typedef u32 uintptr_t; + +#define INT8_MIN (-0x80) +#define INT16_MIN (-0x8000) +#define INT32_MIN (-0x80000000) +#define INT64_MIN (-0x8000000000000000) + +#define INT8_MAX 0x7F +#define INT16_MAX 0x7FFF +#define INT32_MAX 0x7FFFFFFF +#define INT64_MAX 0x7FFFFFFFFFFFFFFF + +#define UINT8_MAX 0xFF +#define UINT16_MAX 0xFFFF +#define UINT32_MAX 0xFFFFFFFF +#define UINT64_MAX 0xFFFFFFFFFFFFFFFF + +#define INTPTR_MIN (-0x80000000) +#define INTPTR_MAX 0x7FFFFFFF +#define UINTPTR_MAX 0xFFFFFFFF + + +#endif /* STDINT_H */ diff --git a/include/uv_clocks.h b/include/uv_clocks.h index 76feac0..80ed369 100644 --- a/include/uv_clocks.h +++ b/include/uv_clocks.h @@ -5,8 +5,8 @@ #include typedef struct uvClockState { - s32 unk0; - s32 unk4; + u32 unk0; + u32 unk4; } uvClockState_t; void uvClkInit(void); diff --git a/include/uv_dobj.h b/include/uv_dobj.h index 90e15f0..d55aa97 100644 --- a/include/uv_dobj.h +++ b/include/uv_dobj.h @@ -14,7 +14,7 @@ typedef struct { s32 unk3C; } Unk80263780; -extern Unk80263780 D_80263780[8]; +extern Unk80263780 D_80263780[100]; s32 func_8021731C(void); // arg1 might be the model id? 0xFFFF / -1 is..? diff --git a/include/uv_graphics.h b/include/uv_graphics.h index d00370f..9dfad7a 100644 --- a/include/uv_graphics.h +++ b/include/uv_graphics.h @@ -38,8 +38,14 @@ typedef struct { } uvGfxViewport_t; typedef struct { - u8 pad[0x58]; -} UnkStruct_uvGfxInit; + s32 unk0; + u8 pad[0x4]; + s32 unk8; + u8* fb; + OSTask task; + OSMesgQueue* msgQueue; + void* unk54; +} UnkStruct_uvGfxInit; // size: 0x58 typedef struct { void* unk0; @@ -48,7 +54,8 @@ typedef struct { u16 width; u16 height; u8 unkE; - u8 padF[0x5]; + u8 padF[0x3]; + u16 unk12; u16 unk14; struct unk_UVTX_1C* unk18; struct unk_UVTX_1C* unk1C; diff --git a/src/kernel/clocks.c b/src/kernel/clocks.c index 56eaead..9e483aa 100644 --- a/src/kernel/clocks.c +++ b/src/kernel/clocks.c @@ -13,20 +13,35 @@ void uvClkUpdate(void) { u32 count; count = osGetCount(); - if (((u32)D_80263470 >= 0xF0000001U) && (count < 0x10000000U)) { + if ((D_80263470 >= 0xF0000001) && (count < 0x10000000)) { D_80263474 += 1; } D_80263470 = count; } -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/clocks/uvClkGetSec.s") +f64 uvClkGetSec(s32 clk_id) { + f64 var_fv1; + f64 var_fa0; + + if (clk_id >= 8) { + _uvDebugPrintf("uvClkGetSec: unknown clock %d\n", clk_id); + return 0.0; + } + uvClkUpdate(); + var_fv1 = D_80263474 - D_80263478[clk_id].unk0; + var_fv1 *= 93.875101696; + + var_fa0 = ((f64)D_80263470 - D_80263478[clk_id].unk4) / 45751932.284543216; + + return var_fv1 + var_fa0; +} void uvClkReset(s32 clk_id) { uvClockState_t* temp_v0; uvClkUpdate(); temp_v0 = &D_80263478[clk_id]; - temp_v0->unk4 = (s32)D_80263470; - temp_v0->unk0 = (s32)D_80263474; + temp_v0->unk4 = D_80263470; + temp_v0->unk0 = D_80263474; } diff --git a/src/kernel/graphics.c b/src/kernel/graphics.c index 2b5157a..72e9267 100644 --- a/src/kernel/graphics.c +++ b/src/kernel/graphics.c @@ -1,9 +1,13 @@ +#include +#include #include #include #include #include #include #include +#include +#include void func_80218CA4(void); void func_8021A298(void); @@ -44,7 +48,7 @@ s32 D_80249200 = 0; s32 gGfxBeginFlag = 0; f32 D_80249208 = 0; u16 gGfxFbIndex = 0; -s32 D_80249210 = 0; +s32 gGfxElementCount = 0; s32 D_80249214 = 0; s16 gGfxMstackIdx = 0xFFFF; f32 D_8024921C = -1; @@ -54,19 +58,12 @@ f32 D_80249228 = 1.880898581e-37; f32 D_8024922C = 9.367220608e-38; static uvGfxCallback_t D_80249230 = NULL; -static s32 D_80249234 = 0x00000FA0; -static s32 D_80249238 = 0x00000126; -static s32 D_8024923C = 0x000000C8; -static s32 D_80249240 = 0x00000064; -static s32 D_80249244 = 0x00000078; -static s32 D_80249248 = 0x00000320; -static s32 D_8024924C = 0x00000000; extern uvGfxUnkStruct* gGfxUnkPtrs; extern u8 D_80296AA0[]; extern u8 D_80296AA8[]; -extern u8* D_80298AA8; -extern u8* D_80298AAC; +extern u8* gGfxTaskOutputBufferStart; +extern u8* gGfxTaskOutputBufferEnd; extern s32 D_80298AB8[]; extern s32 D_80298AC0[]; extern s32 D_80298AC8[]; @@ -78,7 +75,7 @@ typedef Mtx MtxStack_t[UV_GFX_NUM_MATRICES]; extern s32 gGfxLookCount; extern MtxStack_t gGfxMstack[2]; extern u8* gGfxFbPtrs[2]; -extern s32 D_8029926C; +extern u32 D_8029926C; extern u8* D_80299278; extern uvGfxViewport_t gGfxViewports[]; @@ -107,6 +104,22 @@ extern UnkStruct_uvGfxInit D_802B4950[]; typedef Gfx uvDisplayListBuf_t[0x1068]; extern uvDisplayListBuf_t gGfxDisplayListBase[2]; +extern OSMesgQueue D_802C3B90; +extern s32 D_8024B260; +extern u64 gGfxDramStack[]; +extern u8 gGfxYieldData[]; +extern OSSched gSchedInst; +extern u8 D_80269B80[300]; +extern s16 gGeomVertexCount; + +typedef struct { + u8 pad0[0x4]; + u8 unk4; + u8 pad5[0xAB]; +} unk8028B400; + +extern unk8028B400 D_8028B400[120]; + void uvGfxInit(void) { u8 i; @@ -135,8 +148,8 @@ void uvGfxInit(void) { D_802491D8[1] = 0.0f; D_802491D8[0] = (f32)D_802491D8[1]; uvGfxEnableGamma(0); - D_80298AA8 = ((s32)&D_80296AA0 & 0xF) ? D_80296AA8 : D_80296AA0; - D_80298AAC = D_80298AA8 + 0x2000; + gGfxTaskOutputBufferStart = ((s32)&D_80296AA0 & 0xF) ? D_80296AA8 : D_80296AA0; + gGfxTaskOutputBufferEnd = gGfxTaskOutputBufferStart + 0x2000; } void uvGfxBegin(void) { @@ -163,9 +176,6 @@ void uvGfxBegin(void) { gGfxLookCount = 0; } -#ifndef NON_MATCHING -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/graphics/uvGfxSetFogFactor.s") -#else void uvGfxSetFogFactor(f32 arg0) { if (arg0 < 0.0f) { arg0 = 0.0f; @@ -176,13 +186,11 @@ void uvGfxSetFogFactor(f32 arg0) { D_80249208 = arg0; if (arg0 > 0.0f) { gSPSetGeometryMode(gGfxDisplayListHead++, G_FOG); - gSPFogFactor(gGfxDisplayListHead++, (((s32)(D_80249208 * 1000.0f) * -0x100) + 0x1F400) / (s32)(0x3E8 - (s32)(D_80249208 * 1000.0f)), - 0x1F400 / (s32)(0x3E8 - (s32)(D_80249208 * 1000.0f))); + gSPFogPosition(gGfxDisplayListHead++, (s32)(D_80249208 * 1000.0f), 1000); } else { gSPClearGeometryMode(gGfxDisplayListHead++, G_FOG); } } -#endif void uvGfxResetState(void) { if (D_80249208 > 0.0f) { @@ -247,7 +255,201 @@ void uvGfxStateDrawDL(uvGfxState_t* arg0) { D_80298AC0[gGfxFbIndex] += arg0->unk6 * 2; } -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/graphics/uvGfxStateDraw.s") +void uvGfxStateDraw(uvGfxState_t* arg0) { + u32 clearMode; + u32 setMode; + u16 var_t2; + uvGfxUnkStruct2* sp68; + u16 var_t1; + s32 sp60; + u32 var_a1_2; + u32 renderMode1; + u32 renderMode2; + u32 var_a3; + + var_a3 = arg0->unk0; + if (D_80249208 > 0.0f) { + var_a3 |= 0x80020000; + } + var_a3 |= D_802491E0; + var_a3 &= D_802491E4; + + if (var_a3 & 0x02000000) { + uvGfxStateDrawDL(arg0); + return; + } + if (var_a3 != (u32)gGfxStateStackData) { + gDPPipeSync(gGfxDisplayListHead++); + if ((var_a3 & 0x883E0000) != (gGfxStateStackData & 0x883E0000)) { + setMode = 0; + clearMode = 0; + if (var_a3 & 0x08000000) { + setMode = G_TEXTURE_GEN | G_LIGHTING; + } else { + clearMode = G_TEXTURE_GEN | G_LIGHTING; + } + if (var_a3 & 0x100000) { + setMode |= G_CULL_BACK; + } else { + clearMode |= G_CULL_BACK; + } + if (var_a3 & 0x80000) { + setMode |= G_CULL_FRONT; + } else { + clearMode |= G_CULL_FRONT; + } + if (var_a3 & 0x20000) { + setMode |= G_SHADING_SMOOTH; + } else { + clearMode |= G_SHADING_SMOOTH; + } + if (var_a3 & 0x200000) { + setMode |= G_ZBUFFER; + } else { + clearMode |= G_ZBUFFER; + } + if (var_a3 & 0x80000000) { + setMode |= G_FOG; + } else { + clearMode |= G_FOG; + } + if (clearMode != 0) { + gSPClearGeometryMode(gGfxDisplayListHead++, clearMode); + } + if (setMode != 0) { + gSPSetGeometryMode(gGfxDisplayListHead++, setMode); + } + } + var_t2 = var_a3 & 0xFFF; + + if (var_t2 == 0xFFE) { + var_t2++; + } + + if (var_t2 >= 0xFFF) { + var_t1 = 0xFFF; + } else { + sp68 = gGfxUnkPtrs->unk910[var_t2]; + if (sp68 == NULL) { + _uvDebugPrintf("uvGfxStateDraw: texture %d not in level\n", var_t2); + var_t1 = 0xFFF; + var_t2 = 0xFFF; + } else { + var_t1 = (sp68->unk12 & 0xF000) | var_t2; + } + } + + if (D_8029926C != var_t1) { + if (var_t2 >= 0xFFE) { + gSPDisplayList(gGfxDisplayListHead++, gGfxDList2); + } else { + _uvTxtDraw(var_t2); + D_80298AC8[gGfxFbIndex]++; + if (var_a3 & 0x08000000) { + gDPSetCombineMode(gGfxDisplayListHead++, G_CC_DECALRGB, G_CC_DECALRGB2); + gSPTexture(gGfxDisplayListHead++, 0x7C0, 0x7C0, 0, 1, G_ON); + } + } + } + if (var_a3 & 0x01000000) { + var_a1_2 = 0x10; + } else { + var_a1_2 = 0; + } + + uvGfx_80223A64(var_t2, var_a1_2); + + sp60 = 0x01E00000; + switch (var_a3 & sp60) { + case 0x1C00000: + case 0x1E00000: + renderMode2 = G_RM_AA_ZB_XLU_DECAL2; + break; + case 0x1800000: + case 0x1A00000: + renderMode2 = G_RM_ZB_XLU_DECAL2; + break; + case 0x1400000: + case 0x1600000: + renderMode2 = G_RM_AA_ZB_OPA_DECAL2; + break; + case 0x1000000: + case 0x1200000: + renderMode2 = G_RM_ZB_OPA_DECAL2; + break; + case 0xE00000: + if (var_t2 == 0xFFF) { + renderMode2 = G_RM_AA_ZB_XLU_INTER2; + } else if ((sp68->unk12 & 0x8000) || (sp68->unk22 == 1) || (var_a3 & 0x04000000)) { + renderMode2 = G_RM_AA_ZB_XLU_SURF2; + } else { + renderMode2 = G_RM_AA_ZB_TEX_TERR2; + } + break; + case 0xC00000: + if (var_t2 == 0xFFF) { + renderMode2 = G_RM_AA_XLU_SURF2; + } else if (sp68->unk12 & 0x8000) { + renderMode2 = G_RM_AA_XLU_SURF2; + } else { + renderMode2 = G_RM_AA_TEX_TERR2; + } + break; + case 0xA00000: + if (var_t2 == 0xFFF) { + renderMode2 = G_RM_ZB_XLU_SURF2; + } else { + renderMode2 = G_RM_ZB_XLU_SURF2; + } + break; + case 0x600000: + renderMode2 = G_RM_AA_ZB_OPA_TERR2; + break; + case 0x200000: + renderMode2 = G_RM_ZB_OPA_SURF2; + break; + case 0x400000: + renderMode2 = G_RM_AA_OPA_TERR2; + break; + case 0x800000: + renderMode2 = G_RM_XLU_SURF2; + break; + case 0x0: + renderMode2 = G_RM_OPA_SURF2; + break; + default: + _uvDebugPrintf("uvGfxStateDraw: unknown case 0x%x\n", var_a3 & sp60); + renderMode2 = G_RM_OPA_SURF2; + break; + } + if (var_a3 & 0x80000000) { + renderMode1 = G_RM_FOG_SHADE_A; + } else { + renderMode1 = G_RM_PASS; + } + if (var_a3 & 0x10000000) { + renderMode2 = Z_CMP | Z_UPD | IM_RD | CLR_ON_CVG | CVG_DST_SAVE | ZMODE_OPA | GBL_c2(G_BL_CLR_MEM, G_BL_A_FOG, G_BL_CLR_MEM, G_BL_A_MEM); + } + + gDPSetRenderMode(gGfxDisplayListHead++, renderMode1, renderMode2); + + D_8029926C = var_t1; + gGfxStateStackData = var_a3; + } + if ((var_a3 & 0x80000000) && ((var_a3 & sp60) == 0xE00000)) { + if (var_t2 == 0xFFF) { + gDPSetCombineMode(gGfxDisplayListHead++, G_CC_SHADE, G_CC_PASS2); + } else { + gDPSetCombineMode(gGfxDisplayListHead++, G_CC_MODULATEIDECALA, G_CC_PASS2); + } + } + if (arg0->unk8 != NULL) { + gSPDisplayList(gGfxDisplayListHead++, arg0->unk8); + + D_80298AB8[gGfxFbIndex] += arg0->unk4; + D_80298AC0[gGfxFbIndex] += arg0->unk6; + } +} void uvGfxPushMtxUnk(Mtx4F* arg0) { Mtx4F spC8; @@ -263,7 +465,91 @@ void uvGfxPushMtxUnk(Mtx4F* arg0) { uvGfxMtxView(*(Mtx*)&spC8); } -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/graphics/uvGfxClampLook.s") +void uvGfxClampLook(LookAt* arg0, f32 arg1, f32 arg2, f32 arg3, f32 arg4, f32 arg5, f32 arg6, f32 arg7, f32 arg8, f32 arg9) { + f32 sp5C; + f32 sp58; + f32 sp54; + f32 sp50; + f32 sp4C; + f32 sp48; + f32 sp44; + f32 temp_fv0_2; + + sp58 = arg4 - arg1; + sp54 = arg5 - arg2; + sp50 = arg6 - arg3; + + temp_fv0_2 = sqrtf(SQ(sp58) + SQ(sp54) + SQ(sp50)); + if (temp_fv0_2 != 0.0f) { + sp5C = -1.0f / temp_fv0_2; + } else { + // clang-format off + sp5C = -255.0f; \ + _uvDebugPrintf("clamping 1\n"); + // clang-format on + } + sp58 *= sp5C; + sp54 *= sp5C; + sp50 *= sp5C; + + sp4C = (arg8 * sp50) - (arg9 * sp54); + sp48 = (arg9 * sp58) - (arg7 * sp50); + sp44 = (arg7 * sp54) - (arg8 * sp58); + + temp_fv0_2 = sqrtf(SQ(sp4C) + SQ(sp48) + SQ(sp44)); + if (temp_fv0_2 != 0.0f) { + sp5C = 1.0f / temp_fv0_2; + } else { + // clang-format off + sp5C = 255.0f; \ + _uvDebugPrintf("clamping 1\n"); + // clang-format on + } + sp4C *= sp5C; + sp48 *= sp5C; + sp44 *= sp5C; + + arg7 = (sp54 * sp44) - (sp50 * sp48); + arg8 = (sp50 * sp4C) - (sp58 * sp44); + arg9 = (sp58 * sp48) - (sp54 * sp4C); + + temp_fv0_2 = sqrtf(SQ(arg7) + SQ(arg8) + SQ(arg9)); + if (temp_fv0_2 != 0.0f) { + sp5C = 1.0f / temp_fv0_2; + } else { + // clang-format off + sp5C = 255.0f; \ + _uvDebugPrintf("clamping 1\n"); + // clang-format on + } + arg7 *= sp5C; + arg8 *= sp5C; + arg9 *= sp5C; + + arg0->l[0].l.dir[0] = (s32)MIN(sp4C * 128.0, 127.0) & 0xFF; + arg0->l[0].l.dir[1] = (s32)MIN(sp48 * 128.0, 127.0) & 0xFF; + arg0->l[0].l.dir[2] = (s32)MIN(sp44 * 128.0, 127.0) & 0xFF; + + arg0->l[1].l.dir[0] = (s32)MIN(arg7 * 128.0, 127.0) & 0xFF; + arg0->l[1].l.dir[1] = (s32)MIN(arg8 * 128.0, 127.0) & 0xFF; + arg0->l[1].l.dir[2] = (s32)MIN(arg9 * 128.0, 127.0) & 0xFF; + arg0->l[0].l.col[0] = 0; + arg0->l[0].l.col[1] = 0; + arg0->l[0].l.col[2] = 0; + arg0->l[0].l.pad1 = 0; + arg0->l[0].l.colc[0] = 0; + arg0->l[0].l.colc[1] = 0; + arg0->l[0].l.colc[2] = 0; + arg0->l[0].l.pad2 = 0; + arg0->l[1].l.col[0] = 0; + arg0->l[1].l.col[1] = 0x80; + arg0->l[1].l.col[2] = 0; + arg0->l[1].l.pad1 = 0; + arg0->l[1].l.colc[0] = 0; + arg0->l[1].l.colc[1] = 0x80; + arg0->l[1].l.colc[2] = 0; + arg0->l[1].l.pad2 = 0; +} void uvGfxLookAt(Mtx4F* arg0) { Mtx4F temp; @@ -290,7 +576,165 @@ void uvGfxSetCallback(uvGfxCallback_t cb) { D_80249230 = cb; } -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/graphics/uvGfxEnd.s") +void uvGfxEnd(void) { + static s32 D_80249234 = 0x00000FA0; + static s32 D_80249238 = 0x00000126; + static s32 D_8024923C = 0x000000C8; + static s32 D_80249240 = 0x00000064; + static s32 D_80249244 = 0x00000078; + static s32 D_80249248 = 0x00000320; + static s32 D_8024924C = 0x00000000; + s32 i; + s32 pad[4]; + u8* fb; + s32 var_a2; + s32 var_t0; + s32 var_t1; + s32 var_a1; + OSTask* task; + + if (gGfxBeginFlag == 0) { + _uvDebugPrintf("uvGfxEnd: must be called after a uvGfxBegin()\n"); + return; + } + gGfxBeginFlag = 0; + gDPFullSync(gGfxDisplayListHead++); + gSPEndDisplayList(gGfxDisplayListHead++); + gGfxElementCount = (gGfxDisplayListHead - (gGfxDisplayListBase[gGfxFbIndex])); + + if (gGfxElementCount >= 4200) { + _uvDebugPrintf("display list overflow %d / %d\n", gGfxElementCount, 4200); + return; + } + D_802B494C->fb = gGfxFbPtrs[gGfxFbIndex]; + D_802B494C->unk0 = 0; + D_802B494C->msgQueue = &D_802C3B90; + D_802B494C->unk54 = &D_8024B260; + D_802B494C->unk8 = 0x53; + task = &D_802B4950[gGfxFbIndex].task; + task->t.type = M_GFXTASK; + task->t.flags = 0; + task->t.ucode_boot = (u64*)rspbootTextStart; + task->t.ucode_boot_size = (uintptr_t)rspbootTextEnd - (uintptr_t)rspbootTextStart; + task->t.ucode = (u64*)gspF3DEX_fifoTextStart; + task->t.ucode_data = (u64*)gspF3DEX_fifoDataStart; + task->t.ucode_size = SP_UCODE_SIZE; + task->t.ucode_data_size = SP_UCODE_DATA_SIZE; + task->t.dram_stack = gGfxDramStack; + task->t.dram_stack_size = SP_DRAM_STACK_SIZE8; + task->t.data_ptr = (u64*)gGfxDisplayListBase[gGfxFbIndex]; + task->t.data_size = gGfxElementCount * sizeof(Gfx); + task->t.yield_data_ptr = (u64*)gGfxYieldData; + task->t.yield_data_size = OS_YIELD_DATA_SIZE; + task->t.ucode = (u64*)gspFast3DTextStart; + task->t.ucode_data = (u64*)gspFast3DDataStart; + task->t.output_buff = (u64*)gGfxTaskOutputBufferStart; + task->t.output_buff_size = (u64*)gGfxTaskOutputBufferEnd; + func_8022C3C0(0, 0x2B); + osSendMesg(_uvScGetCmdQ(&gSchedInst), D_802B494C, 1); + uvEventPost(1, 0); + if (D_80249214 == 0) { + osViBlack(FALSE); + } else if (D_80249200 != 0) { + uvWaitForMesg(4); + } + D_80249200 = 1; + fb = gGfxFbPtrs[gGfxFbIndex ^ 1]; + if (D_80249230 != NULL) { + D_80249230(fb, D_80299278); + osWritebackDCache(fb, 0x25800); + } + D_802491D8[gGfxFbIndex] = (f32)uvClkGetSec(3); + uvClkReset(3); + func_8022C3C0(0, 0x2A); + var_a2 = 0; + var_t0 = 0; + var_t1 = 0; + var_a1 = FALSE; + + for (i = 0; i < 300; i++) { + if (D_80269B80[i] != 0) { + var_a2++; + } + } + + for (i = 0; i < 100; i++) { + if (D_80263780[i].unk0 != 0xFFFF) { + var_t0++; + } + } + + for (i = 0; i < 120; i++) { + if (D_8028B400[i].unk4 != 0) { + var_t1++; + } + } + if (D_80249234 < gGfxElementCount) { + D_80249234 = gGfxElementCount; + var_a1 = TRUE; + } + if (D_80249238 < gGfxMstackIdx) { + D_80249238 = gGfxMstackIdx; + var_a1 = TRUE; + } + if (D_8024923C < var_a2) { + D_8024923C = var_a2; + var_a1 = TRUE; + } + if (D_80249240 < var_t0) { + D_80249240 = var_t0; + var_a1 = TRUE; + } + if (D_80249244 < var_t1) { + D_80249244 = var_t1; + var_a1 = TRUE; + } + if (D_80249248 < gGeomVertexCount) { + D_80249248 = gGeomVertexCount; + var_a1 = TRUE; + } + if (var_a1) { + _uvDebugPrintf("\nGFXEND :\n"); + _uvDebugPrintf("DL_ELEMENTS : %d", D_80249234); + if (D_80249234 == gGfxElementCount) { + _uvDebugPrintf(" <==== WINNER"); + } + + _uvDebugPrintf("\n"); + _uvDebugPrintf("DL_NDBMTXS : %d", D_80249238); + if (D_80249238 == gGfxMstackIdx) { + _uvDebugPrintf(" <==== WINNER"); + } + _uvDebugPrintf("\n"); + _uvDebugPrintf("OBJ_NPXFMS : %d", D_8024923C); + if (var_a2 == D_8024923C) { + _uvDebugPrintf(" <==== WINNER"); + } + _uvDebugPrintf("\n"); + _uvDebugPrintf("OBJ_NDOBJS : %d", D_80249240); + if (var_t0 == D_80249240) { + _uvDebugPrintf(" <==== WINNER"); + } + _uvDebugPrintf("\n"); + _uvDebugPrintf("FX_NFX : %d", D_80249244); + if (var_t1 == D_80249244) { + _uvDebugPrintf(" <==== WINNER"); + } + _uvDebugPrintf("\n"); + _uvDebugPrintf("GEOM_NDBVTXS: %d", D_80249248); + if (D_80249248 == gGeomVertexCount) { + _uvDebugPrintf(" <==== WINNER"); + } + _uvDebugPrintf("\n"); + } + + gGfxFbIndex ^= 1; + gGfxMstackIdx = -1; + D_802B494C = &D_802B4950[gGfxFbIndex]; + gGfxFbCurrPtr = gGfxFbPtrs[gGfxFbIndex]; + gGfxDisplayListHead = gGfxDisplayListBase[gGfxFbIndex]; + D_80249214++; +} void uvGfxClearScreen(u8 r, u8 g, u8 b, u8 a) { gDPPipeSync(gGfxDisplayListHead++); @@ -364,7 +808,71 @@ void uvGfxEnableLighting(s32 enable) { } } -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/graphics/uvGfxClipRect.s") +void uvGfxClipRect(uvGfxViewport_t* arg0, s32 arg1, s32 arg2, s32 arg3, s32 arg4) { + s32 var_a2; + s32 var_a3; + + arg0->x0 = arg1; + arg0->x1 = arg2; + arg0->y0 = arg3; + arg0->y1 = arg4; + if (arg0->x0 < 0) { + arg0->x0 = 0; + } else if (arg0->x0 > 320) { + arg0->x0 = 320; + } + + if (arg0->x1 < 0) { + arg0->x1 = 0; + } else if (arg0->x1 > 320) { + arg0->x1 = 320; + } + + if (arg0->y1 < 0) { + arg0->y1 = 0; + } else if (arg0->y1 > 240) { + arg0->y1 = 240; + } + + if (arg0->y0 < 0) { + arg0->y0 = 0; + } else if (arg0->y0 > 240) { + arg0->y0 = 240; + } + + arg0->unk0 = arg0->x0 - 5; + if (arg0->unk0 < 0) { + arg0->unk0 = 0; + } + arg0->unk2 = arg0->x1 + 5; + if (arg0->unk2 > 319) { + arg0->unk2 = 319; + } + arg0->unk4 = arg0->y0 - 5; + if (arg0->unk4 < 0) { + arg0->unk4 = 0; + } + arg0->unk6 = arg0->y1 + 5; + if (arg0->unk6 > 239) { + arg0->unk6 = 239; + } + + var_a2 = arg0->unk2 - arg0->unk0; + var_a3 = arg0->unk6 - arg0->unk4; + + arg0->vp.vp.vscale[0] = (var_a2 << 1); + arg0->vp.vp.vscale[1] = (var_a3 << 1); + arg0->vp.vp.vscale[2] = 0x1FF; + arg0->vp.vp.vscale[3] = 0; + arg0->vp.vp.vtrans[0] = (u16)((arg0->unk0 + (var_a2 >> 1)) & 0xFFFF) << 2; + arg0->vp.vp.vtrans[1] = (u16)(((240 - arg0->unk4) - (var_a3 >> 1)) & 0xFFFF) << 2; + arg0->vp.vp.vtrans[2] = 0x1FF; + arg0->vp.vp.vtrans[3] = 0; + gGfxViewX0 = arg0->x0; + gGfxViewX1 = arg0->x1; + gGfxViewY0 = arg0->y0; + gGfxViewY1 = arg0->y1; +} void uvGfxClipViewport(s32 vp_id, s32 arg1, s32 arg2, s32 arg3, s32 arg4) { uvGfxClipRect(&gGfxViewports[vp_id], arg1, arg2, arg3, arg4); @@ -566,14 +1074,15 @@ void uvGfx_80223A28(s32 flags) { void uvGfx_80223A64(s32 arg0, s32 arg1) { s32 var_v0; + u32 var_a0; var_v0 = gGfxStateStackData & 0x01000000; if (arg1 != 0) { var_v0 ^= 0x01000000; } if (arg0 == 0xFFF) { - arg0 = gGfxStateStackData & 0xFFF; - if (arg0 == 0xFFFU) { + var_a0 = gGfxStateStackData & 0xFFF; + if (var_a0 == 0xFFF) { if (var_v0 == 0) { return; } @@ -645,6 +1154,6 @@ void uvCopyFrameBuf(s32 fb_id) { } src = gGfxFbPtrs[fb_id]; dst = gGfxFbPtrs[fb_id ^ 1]; - _uvMediaCopy(dst, src, 0x25800U); + _uvMediaCopy(dst, src, 0x25800); } diff --git a/src/kernel/seq.c b/src/kernel/seq.c index 7e95eaf..393f4ff 100644 --- a/src/kernel/seq.c +++ b/src/kernel/seq.c @@ -1,24 +1,19 @@ #include #include #include +#include -extern ALSeqPlayer* gSeqPlayer; - -#ifndef NON_MATCHING -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/seq/uvaSeqNew.s") -#else -void _uvMediaCopy(void*, void*, s32); -void uvaSeqStop(void); extern ALSeqPlayer* gSeqPlayer; extern ALBank* D_80261210; -extern u8* D_8026121C; +extern ALSeqFile* D_8026121C; extern u8* D_80261220; extern ALCSeq D_80261230; + void uvaSeqNew(s32 arg0) { s32 seq_count; s32 seq_align; - seq_count = ((ALSeqFile*)(D_8026121C + arg0 * 8))->seqArray[0].len; + seq_count = D_8026121C->seqArray[arg0].len; seq_align = seq_count; if (seq_count & 1) { seq_align = seq_count + 1; @@ -27,12 +22,11 @@ void uvaSeqNew(s32 arg0) { if (alSeqpGetState(gSeqPlayer) != 0) { uvaSeqStop(); } - _uvMediaCopy(D_80261220, ((ALSeqFile*)(D_8026121C + arg0 * 8))->seqArray[0].offset, seq_align); + _uvMediaCopy(D_80261220, D_8026121C->seqArray[arg0].offset, seq_align); alCSeqNew(&D_80261230, D_80261220); alSeqpSetBank(gSeqPlayer, D_80261210); alSeqpSetSeq(gSeqPlayer, (ALSeq*)&D_80261230); } -#endif void uvaSeqPlay(void) { if (alSeqpGetState(gSeqPlayer) != 0) { From df84086e555732cbe1467e0056606d2313537632 Mon Sep 17 00:00:00 2001 From: inspectredc <78732756+inspectredc@users.noreply.github.com> Date: Sun, 15 Feb 2026 21:11:03 +0000 Subject: [PATCH 2/3] dobj matching --- config/us/sym/symbol_addrs_libultra.txt | 1 - include/uv_dobj.h | 2 +- include/uv_graphics.h | 31 +- include/uv_model.h | 2 +- include/uv_sched.h | 11 +- src/kernel/code_8170.c | 2 +- src/kernel/dobj.c | 571 ++++++++++++++++++++++-- 7 files changed, 588 insertions(+), 32 deletions(-) diff --git a/config/us/sym/symbol_addrs_libultra.txt b/config/us/sym/symbol_addrs_libultra.txt index e02afe7..d39e777 100644 --- a/config/us/sym/symbol_addrs_libultra.txt +++ b/config/us/sym/symbol_addrs_libultra.txt @@ -274,7 +274,6 @@ __osSetCompare = 0x80245480; __osSiDeviceBusy = 0x80245490; __osGetCause = 0x802454C0; __osAtomicDec = 0x802454D0; -__additional_scanline = 0x80248DD8; alGlobals = 0x8024B780; aisetnextbuf_data_0000 = 0x8024B790; sprite_data_0004 = 0x8024B7A4; diff --git a/include/uv_dobj.h b/include/uv_dobj.h index d55aa97..60a5e0e 100644 --- a/include/uv_dobj.h +++ b/include/uv_dobj.h @@ -9,7 +9,7 @@ typedef struct { u16 unk0; u16 unk2[1]; // unknown size, might take up everything till unk34 u8 pad4[0x34-0x4]; - s8 unk34; + u8 unk34; f32 unk38; s32 unk3C; } Unk80263780; diff --git a/include/uv_graphics.h b/include/uv_graphics.h index 9dfad7a..95eacc0 100644 --- a/include/uv_graphics.h +++ b/include/uv_graphics.h @@ -63,8 +63,33 @@ typedef struct { u8 unk22; } uvGfxUnkStruct2; +typedef struct uvGfxUnkStruct10 { + uvGfxState_t* unk0; + u8 unk4; + u8 pad5[0x1]; + u8 unk6; + u8 pad7[0x6]; + u8 unkD; + u8 padE[0x2]; +} uvGfxUnkStruct10; + +typedef struct uvGfxUnkStruct8 { + uvGfxUnkStruct10* unk0; + u8 unk4; + u8 unk5; + u8 pad6[0x2]; +} uvGfxUnkStruct8; + typedef struct { - u8 pad0[0x1C]; + u8 pad0[0x8]; + uvGfxUnkStruct8* unk8; + f32* unkC; + u8 unk10; + u8 unk11; + u8 pad12[0x2]; + void* unk14; + u8 unk18; + u8 pad19[0x3]; f32 unk1C; f32 unk20; } uvGfxUnkStructC8; @@ -187,7 +212,9 @@ typedef struct { /* 1F4 */ f32 unk1F4; /* 1F8 */ f32 unk1F8; /* 1FC */ f32 unk1FC; -/* 200 */ u8 pad1A4[0xE0]; +/* 200 */ u8 pad200[0x4]; +/* 204 */ f32 unk204; +/* 208 */ u8 pad208[0xD8]; /* 2E0 */ u8 unk2E0[0x90]; /* 370 */ s32 unk370; /* 374 */ s32 unk374; diff --git a/include/uv_model.h b/include/uv_model.h index 1a95ac7..ddc0ccf 100644 --- a/include/uv_model.h +++ b/include/uv_model.h @@ -3,7 +3,7 @@ #include -void uvModelGetProps(u16, s32, void*, s32); +void uvModelGetProps(s32, s32, void*, s32); void uvModelGetPosm(s32 model, s32 part, Mtx4F*); #endif // UV_MODEL_H diff --git a/include/uv_sched.h b/include/uv_sched.h index 91d78cb..5d3f199 100644 --- a/include/uv_sched.h +++ b/include/uv_sched.h @@ -3,12 +3,20 @@ #include #include +#include #include #define UV_MESG_DMA 0 #define UV_MESG_SCHED 2 #define UV_MESG_GFX 4 +typedef struct Unk8022B0A0 { + f32 unk0; + f32 unk4; + f32 unk8; + f32 unkC; +} Unk8022B0A0; // size: 0x10 + void uvWaitForMesg(char msg_type); void _uvScDoneGfx(void); @@ -26,8 +34,9 @@ void _uvScHandleRDP(void); void _uvScHandleNMI(void); void _uvScLogCpuEvent(s32 ring); void _uvScLogIntoRing(void); -void func_8022C34C(void); +void func_8022B0A0(Unk8022B0A0* arg0, Mtx4F* arg1); void func_8022BEB8(s32 arg0); +void func_8022C34C(void); void func_8022C3C0(u8 arg0, s32 arg1); #endif // PILOTWINGS64_UV_SCHED diff --git a/src/kernel/code_8170.c b/src/kernel/code_8170.c index c1bf640..0b26619 100644 --- a/src/kernel/code_8170.c +++ b/src/kernel/code_8170.c @@ -3,7 +3,7 @@ uvGfxUnkStruct* gGfxUnkPtrs = NULL; s32 D_80248DD4 = 0xFFFFFFFF; -s32 __additional_scanline[] = { 0x00000000, 0x00000000 }; +s32 D_80248DD8 = 0x00000000; #pragma GLOBAL_ASM("asm/nonmatchings/kernel/code_8170/osViExtendVStart.s") diff --git a/src/kernel/dobj.c b/src/kernel/dobj.c index 0bda1eb..3e61315 100644 --- a/src/kernel/dobj.c +++ b/src/kernel/dobj.c @@ -1,14 +1,143 @@ #include "common.h" #include +#include +#include +#include #include #include #include +// TODO FIXME fix for gSPPerspNormalize, due to older f3d ucode +#undef gSPPerspNormalize +#define gSPPerspNormalize(pkt, s) \ + { \ + Gfx* _g = (Gfx*)(pkt); \ + \ + _g->words.w0 = _SHIFTL(G_RDPHALF_1, 24, 8); \ + _g->words.w1 = (s); \ + } + +typedef struct Unk80371120 { + Unk8022B0A0 unk0[1]; + u8 pad10[0x180]; + u8 unk190[1]; + u8 pad191[0x1B]; + s32 unk1AC; +} Unk80371120; // size: 0x1B0 + +void _uvSortAdd(s32, f32, Unk80263780*, UnkStruct_80204D94*, f32, f32, ...); +u8 func_80217AB4(uvGfxUnkStructC8*, f32); +void func_80217B4C(Unk80263780*, uvGfxUnkStructC8*, u8); +void func_80217E24(Unk80263780*, uvGfxUnkStructC8*, u8, f32, f32); +s32 func_80206F64(void*, f32, f32, f32, f32); +void func_80215E7C(uvGfxUnkStructC8*); + +extern u8 D_80269B80[300]; extern u16 D_80269CB0[100]; +extern u16 D_80269F08; extern u16 D_80269F0A; extern Mtx4F D_80265080[300]; -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/dobj/uvDobjModel.s") +void uvDobjModel(s32 objId, s32 arg1) { + uvGfxUnkStructC8** temp_a3; + Unk80263780* var_t2; + s32 var_v0_3; + s32 i; + s32 j; + u8 temp_t0; + u8 var_a3_2; + + var_t2 = &D_80263780[objId]; + temp_a3 = gGfxUnkPtrs->unkC8; + + if (arg1 == var_t2->unk0) { + return; + } + + if (objId >= 100) { + _uvDebugPrintf("uvDobjModel - invalid object id number [%d]\n", objId); + return; + } + if (arg1 == 0xFFFF) { + temp_t0 = temp_a3[var_t2->unk0]->unk18; + + for (i = 0; i < temp_t0; i++) { + D_80269B80[var_t2->unk2[i]] = 0; + } + + var_t2->unk0 = 0xFFFF; + for (i = 0; i < D_80269F0A; i++) { + if (objId == D_80269CB0[i]) { + for (j = i; j < D_80269F0A; j++) { + D_80269CB0[j] = D_80269CB0[j + 1]; + } + D_80269F0A--; + } + } + } else { + if (gGfxUnkPtrs->unkC8[arg1] == NULL) { + _uvDebugPrintf("uvDobjModel ( %d, %d ) -- model does not exist in level\n", objId, arg1); + return; + } + var_t2->unk3C = 0; + var_t2->unk38 = temp_a3[arg1]->unk1C; + + if (var_t2->unk0 == 0xFFFF) { + temp_t0 = 0; + } else { + if (temp_a3[var_t2->unk0] != NULL) { + temp_t0 = temp_a3[var_t2->unk0]->unk18; + } else { + temp_t0 = 0; + j = -1; + for (i = 0; i < 25; i++) { + if (j >= var_t2->unk2[i]) { + break; + } + j = var_t2->unk2[i]; + D_80269B80[j] = 0; + if (j) { } + } + } + } + + var_a3_2 = temp_a3[arg1]->unk18; + + if (var_a3_2 < temp_t0) { + for (i = temp_t0 - 1; i >= var_a3_2; i--) { + D_80269B80[var_t2->unk2[i]] = 0; + } + } else { + if (temp_t0 < var_a3_2) { + var_v0_3 = 0; + for (i = temp_t0; i < var_a3_2; i++) { + for (j = var_v0_3; j < 300; j++) { + if (D_80269B80[j] == 0) { + break; + } + } + + if (j == 300) { + _uvDebugPrintf("uvDobjModel : WARNING not enough DL part transforms\n"); + return; + } + + D_80269B80[j] = 1; + var_t2->unk2[i] = j; + var_v0_3 = j + 1; + } + } + } + + var_t2->unk2[var_a3_2] = 0; + + for (i = 0; i < var_a3_2; i++) { + uvMat4Copy(&D_80265080[var_t2->unk2[i]], (u32)temp_a3[arg1]->unk14 + i * sizeof(Mtx4F)); + } + var_t2->unk0 = arg1; + var_t2->unk34 = 3; + } +} void uvDobjProps(s32 arg0, ...) { s16 a1; @@ -55,19 +184,55 @@ void uvDobjProps(s32 arg0, ...) { va_end(args); } -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/dobj/uvDobjPosm.s") +void uvDobjPosm(s32 objId, s32 part, Mtx4F* arg2) { + uvGfxUnkStructC8* temp_v1; + Unk80263780* temp_v0; + f32 temp_fv0; + + if (objId >= 0x65) { + _uvDebugPrintf("uvDobjPosm - invalid object id number [%d]\n", objId); + return; + } + temp_v0 = &D_80263780[objId]; + if (temp_v0->unk0 >= 0x190) { + _uvDebugPrintf("uvDobjPosm: null object id %d\n", objId); + return; + } -void uvDobjGetPosm(s32 arg0, s32 arg1, Mtx4F* arg2) { + uvMat4Copy(&D_80265080[temp_v0->unk2[part]], arg2); + + temp_v1 = gGfxUnkPtrs->unkC8[temp_v0->unk0]; + if (temp_v1 == NULL) { + _uvDebugPrintf("uvDobjPosm: model %d not in level\n", temp_v0->unk0); + return; + } + if (part >= temp_v1->unk8->unk4) { + _uvDebugPrintf("uvDobjPosm: part %d not defined for model %d in obj %d\n", part, temp_v0->unk0, objId); + return; + } + if (part == 0) { + if (temp_v1->unk20 != 1.0f) { + temp_fv0 = 1.0f / temp_v1->unk20; + uvMat4UnkOp3(&D_80265080[temp_v0->unk2[part]], temp_fv0, temp_fv0, temp_fv0); + } + } else { + D_80265080[temp_v0->unk2[part]].m[3][0] *= temp_v1->unk20; + D_80265080[temp_v0->unk2[part]].m[3][1] *= temp_v1->unk20; + D_80265080[temp_v0->unk2[part]].m[3][2] *= temp_v1->unk20; + } +} + +void uvDobjGetPosm(s32 objId, s32 arg1, Mtx4F* arg2) { Unk80263780* sp24; uvGfxUnkStructC8* temp_v0; - if (arg0 >= 0x65) { - _uvDebugPrintf("uvDobjPosm - invalid object id number [%d]\n", arg0); + if (objId >= 0x65) { + _uvDebugPrintf("uvDobjPosm - invalid object id number [%d]\n", objId); return; } - sp24 = &D_80263780[arg0]; + sp24 = &D_80263780[objId]; if (sp24->unk0 >= 0x190) { - _uvDebugPrintf("uvDobjGetPosm: null object id %d\n", arg0); + _uvDebugPrintf("uvDobjGetPosm: null object id %d\n", objId); return; } uvMat4Copy(arg2, &D_80265080[sp24->unk2[arg1]]); @@ -83,27 +248,27 @@ void uvDobjGetPosm(s32 arg0, s32 arg1, Mtx4F* arg2) { } } -void uvDobjState(s32 arg0, s32 arg1) { +void uvDobjState(s32 objId, s32 arg1) { s32 i; s32 j; - if (arg0 >= 0x65) { - _uvDebugPrintf("uvDobjState - invalid object id number [%d]\n", arg0); + if (objId >= 0x65) { + _uvDebugPrintf("uvDobjState - invalid object id number [%d]\n", objId); return; } if (arg1 & 4) { for (i = 0; i < D_80269F0A; i++) { - if (arg0 == D_80269CB0[i]) { + if (objId == D_80269CB0[i]) { break; } } if (i == D_80269F0A) { - D_80269CB0[i] = arg0; + D_80269CB0[i] = objId; D_80269F0A++; } } else { for (i = 0; i < D_80269F0A; i++) { - if (arg0 == D_80269CB0[i]) { + if (objId == D_80269CB0[i]) { for (j = i; j < D_80269F0A; j++) { D_80269CB0[j] = D_80269CB0[j + 1]; } @@ -111,27 +276,383 @@ void uvDobjState(s32 arg0, s32 arg1) { } } } - D_80263780[arg0].unk34 = arg1; + D_80263780[objId].unk34 = arg1; +} + +void uvDobjSetState(s32 objId, s32 arg1) { + if (objId >= 0x65) { + _uvDebugPrintf("uvDobjSetState: no dobj %d\n", objId); + return; + } + + D_80263780[objId].unk34 |= arg1; +} + +void uvDobjSetState2(s32 objId, s32 arg1) { + if (objId >= 0x65) { + _uvDebugPrintf("uvDobjSetState: no dobj %d\n", objId); + return; + } + + D_80263780[objId].unk34 &= ~arg1; } -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/dobj/uvDobjSetState.s") +s32 func_8021731C(void) { + s32 i; -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/dobj/uvDobjSetState2.s") + for (i = 0; i < 100; i++) { + if (D_80263780[i].unk0 == 0xFFFF) { + return i; + } + } + return 0xFFFF; +} -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/dobj/func_8021731C.s") +void func_80217398(void) { + s32 i; -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/dobj/func_80217398.s") + for (i = 0; i < 100; i++) { + D_80263780[i].unk0 = 0xFFFF; + } -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/dobj/_uvDobjsDraw.s") + for (i = 0; i < 100; i++) { + D_80269CB0[i] = 0xFFFF; + } -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/dobj/func_8021771C.s") + for (i = 0; i < 300; i++) { + D_80269B80[i] = 0; + } -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/dobj/func_80217AB4.s") + for (i = 0; i < 300; i++) { + uvMat4SetIdentity(&D_80265080[i]); + } + D_80269F0A = 0; +} -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/dobj/func_80217B34.s") +void _uvDobjsDraw(UnkStruct_80204D94* arg0, s32 arg1) { + Unk80263780* var_s2; + s32 i; + f32 temp_fv0_2; + f32 temp_fv1; + s32 var_v1; + s32 var_a0; + u8 spBF; + f32 temp_fv0; + f32 temp_fs5; + s32 pad; + f32 temp_fs1; + f32 temp_fs2; + f32 temp_fs0; + f32 spA0; + f32 sp9C; + f32 sp98; + uvGfxUnkStructC8* temp_s1; + Mtx4F* temp_v0_2; -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/dobj/func_80217B4C.s") + D_80269F08 = 0; + spA0 = arg0->unk110.m[3][0]; + sp9C = arg0->unk110.m[3][1]; + sp98 = arg0->unk110.m[3][2]; -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/dobj/func_80217E24.s") + for (i = 0; i < 100; i++) { + var_s2 = &D_80263780[i]; + if (var_s2->unk0 == 0xFFFF) { + continue; + } + if (!(var_s2->unk34 & 2) || (var_s2->unk34 & 4)) { + continue; + } + temp_s1 = gGfxUnkPtrs->unkC8[var_s2->unk0]; + if (temp_s1 == NULL) { + _uvDebugPrintf("_uvDobjsDraw: model %d not in level\n", var_s2->unk0); + continue; + } + uvModelGetProps(var_s2->unk0, 5, &spBF, 0); + if (spBF - arg1 != 0) { + continue; + } + temp_v0_2 = &D_80265080[var_s2->unk2[0]]; + temp_fv0 = temp_v0_2->m[3][0]; + temp_fs5 = temp_v0_2->m[3][1]; -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/dobj/func_802180DC.s") + temp_fs1 = temp_v0_2->m[3][0] - spA0; + temp_fs2 = temp_v0_2->m[3][1] - sp9C; + temp_fs0 = temp_v0_2->m[3][2] - sp98; + temp_fv0_2 = uvSqrtF(SQ(temp_fs1) + SQ(temp_fs2) + SQ(temp_fs0)); + temp_fv1 = var_s2->unk38; + if ((temp_fv0_2 < (arg0->unk1FC + temp_fv1)) && (func_80206F64(arg0->unk2E0, temp_fs1, temp_fs2, temp_fs0, temp_fv1) != 0)) { + if (arg0->unk204 == 1.0f) { + var_v1 = func_80217AB4(temp_s1, temp_fv0_2); + } else { + var_v1 = func_80217AB4(temp_s1, arg0->unk204 * temp_fv0_2); + } + if (var_v1 == 0xFF) { + continue; + } + if (arg1 != 0) { + func_80217B4C(var_s2, temp_s1, var_v1); + } else if (temp_s1->unk8[var_v1].unk5 != 0) { + if (temp_s1->unk11 & 1) { + var_a0 = 3; + } else { + var_a0 = -3; + } + _uvSortAdd(var_a0, temp_fv0_2, var_s2, arg0, temp_fv0, temp_fs5, var_v1, temp_fs1, temp_fs2); + } else { + if (temp_s1->unk11 & 1) { + var_a0 = 2; + } else { + var_a0 = -2; + } + _uvSortAdd(var_a0, temp_fv0_2, var_s2, arg0, temp_fv0, temp_fs5, var_v1); + } + } + } +} + +void func_8021771C(UnkStruct_80204D94* arg0) { + uvGfxUnkStructC8* temp_s0; + Unk80263780* temp_s1; + s32 i; + s32 pad; + Mtx4F sp128; + Mtx spE8; + f32 temp_fs2; + f32 temp_fs3; + f32 temp_fs4; + f32 temp_fv0; + f32 temp_fv0_2; + f32 temp_fa0; + f32 var_fs0; + f32 temp_fv1_x; + f32 temp_fa0_x; + f32 temp_fa1_x; + f32 temp_ft4_x; + u8 var_v0; + + if (D_80269F0A == 0) { + return; + } + uvGfx_80222A98(); + uvGfxEnableZBuffer(TRUE); + for (i = 0; i < D_80269F0A; i++) { + temp_s1 = &D_80263780[D_80269CB0[i]]; + if (temp_s1->unk0 == 0xFFFF) { + continue; + } + if (!(temp_s1->unk34 & 2)) { + continue; + } + temp_s0 = gGfxUnkPtrs->unkC8[temp_s1->unk0]; + + temp_fs3 = D_80265080[temp_s1->unk2[0]].m[3][0] - arg0->unk110.m[3][0]; + temp_fs4 = D_80265080[temp_s1->unk2[0]].m[3][1] - arg0->unk110.m[3][1]; + temp_fv0 = D_80265080[temp_s1->unk2[0]].m[3][2] - arg0->unk110.m[3][2]; + temp_fv0_2 = uvSqrtF(SQ(temp_fs3) + SQ(temp_fs4) + SQ(temp_fv0)); + + temp_fa0 = temp_fv0_2 - temp_s1->unk38; + temp_fs2 = temp_s1->unk38 + temp_fv0_2; + if (temp_fa0 > 0.1f) { + var_fs0 = temp_fa0; + } else { + var_fs0 = 0.1f; + } + temp_fv1_x = arg0->unk1E8 * (var_fs0 / arg0->unk1F8); + temp_fa0_x = arg0->unk1EC * (var_fs0 / arg0->unk1F8); + temp_ft4_x = arg0->unk1F4 * (var_fs0 / arg0->unk1F8); + temp_fa1_x = arg0->unk1F0 * (var_fs0 / arg0->unk1F8); + uvMat4SetUnk2(&sp128, temp_fv1_x, temp_fa0_x, temp_fa1_x, temp_ft4_x, var_fs0, temp_fs2); + uvMat4CopyF2L(&spE8, &sp128); + uvGfxMtxProj(spE8); + gSPPerspNormalize(gGfxDisplayListHead++, (s16)(131072.0f / (temp_fs2 + var_fs0))); + + if (arg0->unk204 == 1.0f) { + var_v0 = func_80217AB4(temp_s0, temp_fv0_2); + } else { + var_v0 = func_80217AB4(temp_s0, arg0->unk204 * temp_fv0_2); + } + + if (var_v0 == 0xFF) { + continue; + } + + if (temp_s0->unk8[var_v0].unk5 != 0) { + func_80217E24(temp_s1, temp_s0, var_v0, temp_fs3, temp_fs4); + } else { + func_80217B4C(temp_s1, temp_s0, var_v0); + } + gSPPopMatrix(gGfxDisplayListHead++, G_MTX_PROJECTION); + } +} + +u8 func_80217AB4(uvGfxUnkStructC8* arg0, f32 arg1) { + u8 temp_v1; + u8 i; + f32* temp_v0; + + temp_v0 = arg0->unkC; + temp_v1 = arg0->unk10; + if (temp_v0[temp_v1 - 1] <= arg1) { + return 0xFF; + } + + for (i = temp_v1; i > 0; i--) { + if (temp_v0[i - 1] < arg1) { + return i; + } + } + return 0; +} + +extern s32 D_80269D78[]; + +s32 func_80217B34(s32** arg0) { + *arg0 = D_80269D78; + return D_80269F08; +} + +extern s32 D_80248DD8; + +void func_80217B4C(Unk80263780* arg0, uvGfxUnkStructC8* arg1, u8 arg2) { + uvGfxUnkStruct10* temp_s2; + uvGfxUnkStruct8* temp_s7; + s32 i; + s32 j; + s32 temp_s3; + s32 temp_v1; + Mtx4F sp50; + + D_80269D78[D_80269F08] = arg0 - D_80263780; + D_80269F08++; + if (arg0->unk34 & 8) { + uvGfx_80223C00(); + } + + temp_s7 = &arg1->unk8[arg2]; + for (i = 0; i < temp_s7->unk4; i++) { + temp_s2 = &temp_s7->unk0[i]; + if (i == 0) { + uvGfx_802236CC(&D_80265080[arg0->unk2[0]]); + } else { + uvGfxMtxViewMul(&D_80265080[arg0->unk2[i]], 1); + } + if (temp_s2->unkD != 0) { + uvGfxLookAt(&D_80265080[arg0->unk2[i]]); + } + if (!(arg0->unk3C & (1 << i))) { + for (j = 0; j < temp_s2->unk4; j++) { + if (arg0->unk34 & 0x20) { + temp_s3 = temp_s2->unk0[j].unk0; + temp_s2->unk0[j].unk0 |= 0x10000000; + uvGfxStateDraw(&temp_s2->unk0[j]); + temp_s2->unk0[j].unk0 = temp_s3; + } else { + uvGfxStateDraw(&temp_s2->unk0[j]); + } + } + } + if (i == temp_s7->unk4 - 1) { + break; + } + temp_v1 = temp_s7->unk0[i].unk6 - temp_s7->unk0[i + 1].unk6; + for (j = 0; j <= temp_v1; j++) { + uvGfxMtxViewPop(); + } + } + temp_v1 = temp_s7->unk0[temp_s7->unk4 - 1].unk6; + for (i = 0; i <= temp_v1; i++) { + uvGfxMtxViewPop(); + } + if (D_80248DD8 != 0) { + uvMat4Copy(&sp50, &D_80265080[arg0->unk2[0]]); + uvMat4UnkOp3(&sp50, arg1->unk20, arg1->unk20, arg1->unk20); + uvGfx_802236CC(&sp50); + func_80215E7C(arg1); + uvGfxMtxViewPop(); + } +} + +void func_80217E24(Unk80263780* arg0, uvGfxUnkStructC8* arg1, u8 arg2, f32 arg3, f32 arg4) { + uvGfxUnkStruct10* temp_s2; + uvGfxUnkStruct8* temp_s5; + Mtx4F* temp_s7; + s32 i; + s32 j; + s32 temp_v1; + f32 sp54; + f32 sp50; + f32 sp4C; + f32 sp48; + f32 sp44; + f32 var_fv1; + + sp54 = arg1->unk20; + D_80269D78[D_80269F08] = arg0 - D_80263780; + D_80269F08++; + temp_s5 = &arg1->unk8[arg2]; + temp_s7 = &D_80265080[arg0->unk2[0]]; + sp50 = temp_s7->m[0][0]; + sp4C = temp_s7->m[0][1]; + sp48 = temp_s7->m[1][0]; + sp44 = temp_s7->m[1][1]; + + var_fv1 = MAX(1.0f, uvSqrtF(SQ(arg3) + SQ(arg4))); + + arg3 /= var_fv1; + arg4 /= var_fv1; + + temp_s7->m[0][0] = -arg4 / sp54; + temp_s7->m[0][1] = arg3 / sp54; + temp_s7->m[1][1] = -arg4 / sp54; + temp_s7->m[1][0] = -arg3 / sp54; + + for (i = 0; i < temp_s5->unk4; i++) { + temp_s2 = &temp_s5->unk0[i]; + if (i == 0) { + uvGfx_802236CC(&D_80265080[arg0->unk2[i]]); + } else { + uvGfxMtxViewMul(&D_80265080[arg0->unk2[i]], 1); + } + + for (j = 0; j < temp_s2->unk4; j++) { + uvGfxStateDraw(&temp_s2->unk0[j]); + } + if (i == temp_s5->unk4 - 1) { + break; + } + temp_v1 = temp_s5->unk0[i].unk6 - temp_s5->unk0[i + 1].unk6; + for (j = 0; j <= temp_v1; j++) { + uvGfxMtxViewPop(); + } + } + temp_v1 = temp_s5->unk0[temp_s5->unk4 - 1].unk6; + for (i = 0; i <= temp_v1; i++) { + uvGfxMtxViewPop(); + } + temp_s7->m[0][0] = sp50; + temp_s7->m[0][1] = sp4C; + temp_s7->m[1][0] = sp48; + temp_s7->m[1][1] = sp44; +} + +void func_802180DC(s32 arg0, Unk80371120* arg1) { + Unk80263780* var_s2; + s32 i; + uvGfxUnkStructC8* temp_v0; + Unk8022B0A0* var_s3; + + var_s2 = &D_80263780[arg0]; + temp_v0 = gGfxUnkPtrs->unkC8[var_s2->unk0]; + var_s3 = arg1->unk0; + + if (temp_v0->unk18 > 1) { + arg1->unk1AC = temp_v0->unk18 - 1; + } else { + arg1->unk1AC = 0; + } + + for (i = 0; i < arg1->unk1AC; i++, var_s3++) { + func_8022B0A0(var_s3, &D_80265080[var_s2->unk2[i + 1]]); + arg1->unk190[i] = i + 1; + } +} From d5d39979a69017d2894b936d33b514d3442f0210 Mon Sep 17 00:00:00 2001 From: inspectredc <78732756+inspectredc@users.noreply.github.com> Date: Tue, 17 Feb 2026 00:32:00 +0000 Subject: [PATCH 3/3] match sobj --- include/uv_graphics.h | 41 +++++- include/uv_matrix.h | 14 ++ include/uv_sobj.h | 20 +++ include/uv_sprite.h | 4 +- src/kernel/code_58E0.c | 84 +++++++++++- src/kernel/dobj.c | 28 ++-- src/kernel/graphics.c | 2 +- src/kernel/matrix.c | 7 - src/kernel/sched.c | 53 +++++++- src/kernel/sobj.c | 302 +++++++++++++++++++++++++++++++++++++++-- src/kernel/sprite.c | 10 +- 11 files changed, 518 insertions(+), 47 deletions(-) create mode 100644 include/uv_sobj.h diff --git a/include/uv_graphics.h b/include/uv_graphics.h index 7248cc5..6d6a8f8 100644 --- a/include/uv_graphics.h +++ b/include/uv_graphics.h @@ -47,6 +47,31 @@ typedef struct { void* unk54; } UnkStruct_uvGfxInit; // size: 0x58 +typedef struct UnkTileStruct40 { + u8 pad0[0x10]; + struct UnkSobjDraw* unk10; +} UnkTileStruct40; + +typedef struct uvUnkTileStruct { + u8 pad0[0x40]; + UnkTileStruct40* unk40; + u8 pad44[0x4]; +} uvUnkTileStruct; + +typedef struct uvGfxUnkStructTerra { + f32 unk0; + f32 unk4; + u8 pad8[0x4]; + f32 unkC; + f32 unk10; + u8 pad14[0x4]; + u8 unk18; + f32 unk1C; + f32 unk20; + u8 pad24[0x4]; + uvUnkTileStruct* unk28; +} uvGfxUnkStructTerra; + typedef struct { void* unk0; Gfx *unk4; @@ -61,7 +86,7 @@ typedef struct { struct unk_UVTX_1C* unk1C; u8 pad20[0x2]; u8 unk22; -} uvGfxUnkStruct2; +} uvGfxUnkStructTexture; typedef struct uvGfxUnkStruct10 { uvGfxState_t* unk0; @@ -92,7 +117,7 @@ typedef struct { u8 pad19[0x3]; f32 unk1C; f32 unk20; -} uvGfxUnkStructC8; +} uvGfxUnkStructModel; typedef struct { u8 pad0[0x2]; @@ -105,23 +130,25 @@ typedef struct { s16 nbitmaps; u8 pad10[0x4]; Bitmap* bitmap; -} uvGfxUnkStruct1410; +} uvGfxUnkStructBlit; typedef struct { u8 pad0[0x4]; - void *unk4[1]; + uvGfxUnkStructTerra *unk4[1]; u8 pad8[0x28]; void *unk30[1]; u8 pad34[0x10]; void *unk44[1]; u8 pad48[0x80]; - uvGfxUnkStructC8 *unkC8[1]; + uvGfxUnkStructModel *unkC8[1]; u8 padCC[0x844]; - uvGfxUnkStruct2 *unk910[1]; + uvGfxUnkStructTexture *unk910[1]; u8 pad914[0x7D0]; void *unk10E4[1]; u8 pad10E8[0x328]; - uvGfxUnkStruct1410* unk1410[1]; + uvGfxUnkStructBlit* unk1410[1]; + u8 pad1414[0x1F4]; + f32 unk1608; } uvGfxUnkStruct; extern Gfx* gGfxDisplayListHead; diff --git a/include/uv_matrix.h b/include/uv_matrix.h index c046ca9..b177247 100644 --- a/include/uv_matrix.h +++ b/include/uv_matrix.h @@ -15,6 +15,20 @@ typedef union { }; } Mtx4F; +typedef struct Mtx_u { + u16 i[4][4]; + u16 f[4][4]; +} Mtx_u; + +typedef union { + Mtx_t m; + Mtx_u u; + long long int force_structure_alignment; +} uvMtx; + +#define MTX_TO_PART(mtx) (*(Mtx_u*)&(mtx)) +#define L2F(mtx, i1, i2) ((((s16)MTX_TO_PART(mtx).i[(i1)][(i2)] << 0x10) | ((s16)MTX_TO_PART(mtx).f[(i1)][(i2)] & 0xFFFF)) / 65536.0f) + void _uvDbMstackReset(void); Mtx4F* _uvDbMstackTop(void); void _uvDbMstackPush(Mtx4F* src); diff --git a/include/uv_sobj.h b/include/uv_sobj.h new file mode 100644 index 0000000..1567f7a --- /dev/null +++ b/include/uv_sobj.h @@ -0,0 +1,20 @@ +#ifndef UV_SOBJ_H +#define UV_SOBJ_H + +#include +#include + +typedef struct UnkSobjDraw { + u16 unk0; + Mtx* unk4; + f32 unk8; + f32 unkC; + f32 unk10; + u16 unk14; +} UnkSobjDraw; + +u8 func_8022C7B8(uvGfxUnkStructModel* arg0, f32 arg1); +void func_8022C8D0(UnkSobjDraw* arg0, uvGfxUnkStructModel* arg1, u8 arg2, Mtx4F* arg3); +void func_8022CC28(UnkSobjDraw* arg0, uvGfxUnkStructModel* arg1, u8 arg2, f32 arg3, f32 arg4); + +#endif // UV_SOBJ_H diff --git a/include/uv_sprite.h b/include/uv_sprite.h index c75ec8a..feec581 100644 --- a/include/uv_sprite.h +++ b/include/uv_sprite.h @@ -62,8 +62,8 @@ typedef struct { void uvSprt_80230130(void); void uvSprt_802301A4(void); void _uvTxtDraw(s32 arg0); -void uvSprtFromBitmap(uvSprite_t* arg0, uvGfxUnkStruct2* arg1); -void uvSprt_80230750(uvSprite_t* arg0, uvGfxUnkStruct2* arg1); +void uvSprtFromBitmap(uvSprite_t* arg0, uvGfxUnkStructTexture* arg1); +void uvSprt_80230750(uvSprite_t* arg0, uvGfxUnkStructTexture* arg1); s32 uvSprt_80230898(void); void uvSprtInit(void); void uvSprtDisplayList(uvSprite_t* arg0); diff --git a/src/kernel/code_58E0.c b/src/kernel/code_58E0.c index f9bd2a5..65403f0 100644 --- a/src/kernel/code_58E0.c +++ b/src/kernel/code_58E0.c @@ -1,5 +1,23 @@ #include #include +#include + +typedef struct UnkSortAdd { + s8 unk0; + s8 unk1; + s8 unk2; + f32 unk4; + f32 unk8; + f32 unkC; + void* unk10; + u16 unk14; + s32 unk18; +} UnkSortAdd; + +extern UnkSortAdd D_80261ED8[]; +extern UnkSortAdd D_802629C8[]; +extern s32 D_80263058; +extern s32 D_8026305C; // from kernel/code_7150 void func_802061A0(void*); @@ -147,7 +165,71 @@ void func_802057F4(Mtx4F* arg0, Mtx4F* arg1) { uvMat4UnkOp4(arg0, arg1); } -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/code_58E0/_uvSortAdd.s") +void _uvSortAdd(s32 arg0, f32 arg1, void* arg2, UnkStruct_80204D94* arg3, f32 arg4, f32 arg5, ...) { + UnkSortAdd* var_a1; + uvGfxUnkStructTerra* var_v0; + s32 var_v1; + s32 var_a0; + va_list args; + + if (arg0 > 0) { + if (D_80263058 >= 100) { + _uvDebugPrintf("_uvSortAdd: sort list full %d\n", 100); + return; + } + var_a1 = &D_80261ED8[D_80263058]; + D_80263058++; + } else { + if (D_8026305C >= 60) { + _uvDebugPrintf("_uvSortAdd: dobj list full for %d\n", 60); + return; + } + + var_a1 = &D_802629C8[D_8026305C]; + D_8026305C++; + arg0 = -arg0; + } + var_a1->unk0 = arg0; + var_a1->unk4 = arg1; + var_a1->unk10 = arg2; + if (arg3->unk0 & 2) { + var_v0 = gGfxUnkPtrs->unk4[arg3->unk4]; + } else { + var_v0 = NULL; + } + if (var_v0 != NULL) { + if ((arg4 < var_v0->unk0) || (var_v0->unkC <= arg4) || (arg5 < var_v0->unk4) || (var_v0->unk10 <= arg5)) { + var_a1->unk14 = 0xFFFF; + } else { + var_v1 = (s32)(arg4 - var_v0->unk0) / (s32)var_v0->unk1C; + var_a0 = (s32)(arg5 - var_v0->unk4) / (s32)var_v0->unk20; + var_a1->unk14 = var_v1 + var_v0->unk18 * var_a0; + } + } else { + var_a1->unk14 = 0xFFFF; + } + + va_start(args, arg5); + switch (arg0) { + case 1: + break; + case 2: + var_a1->unk1 = va_arg(args, s32); + break; + case 3: + var_a1->unk1 = va_arg(args, s32); + var_a1->unk8 = va_arg(args, f64); + var_a1->unkC = va_arg(args, f64); + break; + case 4: + var_a1->unk8 = va_arg(args, f64); + var_a1->unkC = va_arg(args, f64); + var_a1->unk18 = va_arg(args, s32); + var_a1->unk2 = va_arg(args, s32); + var_a1->unk1 = va_arg(args, s32); + break; + } +} #pragma GLOBAL_ASM("asm/nonmatchings/kernel/code_58E0/func_80205BFC.s") diff --git a/src/kernel/dobj.c b/src/kernel/dobj.c index 3e61315..acb6562 100644 --- a/src/kernel/dobj.c +++ b/src/kernel/dobj.c @@ -25,12 +25,12 @@ typedef struct Unk80371120 { s32 unk1AC; } Unk80371120; // size: 0x1B0 -void _uvSortAdd(s32, f32, Unk80263780*, UnkStruct_80204D94*, f32, f32, ...); -u8 func_80217AB4(uvGfxUnkStructC8*, f32); -void func_80217B4C(Unk80263780*, uvGfxUnkStructC8*, u8); -void func_80217E24(Unk80263780*, uvGfxUnkStructC8*, u8, f32, f32); +void _uvSortAdd(s32, f32, void*, UnkStruct_80204D94*, f32, f32, ...); +u8 func_80217AB4(uvGfxUnkStructModel*, f32); +void func_80217B4C(Unk80263780*, uvGfxUnkStructModel*, u8); +void func_80217E24(Unk80263780*, uvGfxUnkStructModel*, u8, f32, f32); s32 func_80206F64(void*, f32, f32, f32, f32); -void func_80215E7C(uvGfxUnkStructC8*); +void func_80215E7C(uvGfxUnkStructModel*); extern u8 D_80269B80[300]; extern u16 D_80269CB0[100]; @@ -39,7 +39,7 @@ extern u16 D_80269F0A; extern Mtx4F D_80265080[300]; void uvDobjModel(s32 objId, s32 arg1) { - uvGfxUnkStructC8** temp_a3; + uvGfxUnkStructModel** temp_a3; Unk80263780* var_t2; s32 var_v0_3; s32 i; @@ -185,7 +185,7 @@ void uvDobjProps(s32 arg0, ...) { } void uvDobjPosm(s32 objId, s32 part, Mtx4F* arg2) { - uvGfxUnkStructC8* temp_v1; + uvGfxUnkStructModel* temp_v1; Unk80263780* temp_v0; f32 temp_fv0; @@ -224,7 +224,7 @@ void uvDobjPosm(s32 objId, s32 part, Mtx4F* arg2) { void uvDobjGetPosm(s32 objId, s32 arg1, Mtx4F* arg2) { Unk80263780* sp24; - uvGfxUnkStructC8* temp_v0; + uvGfxUnkStructModel* temp_v0; if (objId >= 0x65) { _uvDebugPrintf("uvDobjPosm - invalid object id number [%d]\n", objId); @@ -346,7 +346,7 @@ void _uvDobjsDraw(UnkStruct_80204D94* arg0, s32 arg1) { f32 spA0; f32 sp9C; f32 sp98; - uvGfxUnkStructC8* temp_s1; + uvGfxUnkStructModel* temp_s1; Mtx4F* temp_v0_2; D_80269F08 = 0; @@ -411,7 +411,7 @@ void _uvDobjsDraw(UnkStruct_80204D94* arg0, s32 arg1) { } void func_8021771C(UnkStruct_80204D94* arg0) { - uvGfxUnkStructC8* temp_s0; + uvGfxUnkStructModel* temp_s0; Unk80263780* temp_s1; s32 i; s32 pad; @@ -485,7 +485,7 @@ void func_8021771C(UnkStruct_80204D94* arg0) { } } -u8 func_80217AB4(uvGfxUnkStructC8* arg0, f32 arg1) { +u8 func_80217AB4(uvGfxUnkStructModel* arg0, f32 arg1) { u8 temp_v1; u8 i; f32* temp_v0; @@ -513,7 +513,7 @@ s32 func_80217B34(s32** arg0) { extern s32 D_80248DD8; -void func_80217B4C(Unk80263780* arg0, uvGfxUnkStructC8* arg1, u8 arg2) { +void func_80217B4C(Unk80263780* arg0, uvGfxUnkStructModel* arg1, u8 arg2) { uvGfxUnkStruct10* temp_s2; uvGfxUnkStruct8* temp_s7; s32 i; @@ -572,7 +572,7 @@ void func_80217B4C(Unk80263780* arg0, uvGfxUnkStructC8* arg1, u8 arg2) { } } -void func_80217E24(Unk80263780* arg0, uvGfxUnkStructC8* arg1, u8 arg2, f32 arg3, f32 arg4) { +void func_80217E24(Unk80263780* arg0, uvGfxUnkStructModel* arg1, u8 arg2, f32 arg3, f32 arg4) { uvGfxUnkStruct10* temp_s2; uvGfxUnkStruct8* temp_s5; Mtx4F* temp_s7; @@ -638,7 +638,7 @@ void func_80217E24(Unk80263780* arg0, uvGfxUnkStructC8* arg1, u8 arg2, f32 arg3, void func_802180DC(s32 arg0, Unk80371120* arg1) { Unk80263780* var_s2; s32 i; - uvGfxUnkStructC8* temp_v0; + uvGfxUnkStructModel* temp_v0; Unk8022B0A0* var_s3; var_s2 = &D_80263780[arg0]; diff --git a/src/kernel/graphics.c b/src/kernel/graphics.c index 72e9267..728eb92 100644 --- a/src/kernel/graphics.c +++ b/src/kernel/graphics.c @@ -259,7 +259,7 @@ void uvGfxStateDraw(uvGfxState_t* arg0) { u32 clearMode; u32 setMode; u16 var_t2; - uvGfxUnkStruct2* sp68; + uvGfxUnkStructTexture* sp68; u16 var_t1; s32 sp60; u32 var_a1_2; diff --git a/src/kernel/matrix.c b/src/kernel/matrix.c index 2eecf91..a141d15 100644 --- a/src/kernel/matrix.c +++ b/src/kernel/matrix.c @@ -88,13 +88,6 @@ void uvMat4CopyL(Mtx* dst, Mtx src) { dst->m[3][3] = src.m[3][3]; } -typedef struct Mtx_u { - u16 i[4][4]; - u16 f[4][4]; -} Mtx_u; -#define MTX_TO_PART(mtx) (*(Mtx_u*)&(mtx)) -#define L2F(mtx, i1, i2) ((((s16)MTX_TO_PART(mtx).i[(i1)][(i2)] << 0x10) | ((s16)MTX_TO_PART(mtx).f[(i1)][(i2)] & 0xFFFF)) / 65536.0f) - void uvMat4CopyL2F(Mtx4F* dst, Mtx src) { Mtx4F* dst2 = dst; s32 pad; diff --git a/src/kernel/sched.c b/src/kernel/sched.c index 21d3df2..fd98840 100644 --- a/src/kernel/sched.c +++ b/src/kernel/sched.c @@ -1,4 +1,5 @@ #include +#include #include #define VIDEO_MSG 666 @@ -31,7 +32,57 @@ extern s32 D_802B9C7C; extern s32 D_802B9C84; extern s32 D_802B9C88; -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/sched/func_8022B0A0.s") +void func_8022B0A0(Unk8022B0A0* arg0, Mtx4F* arg1) { + f32 temp_fa1; + f32 temp_fv0; + f32 temp_fv1; + s32 var_v0; + + temp_fa1 = arg1->m[0][0] + arg1->m[1][1] + arg1->m[2][2]; + + if (temp_fa1 >= 0.0f) { + temp_fv0 = uvSqrtF(temp_fa1 + 1.0f); + temp_fv1 = 0.5f / temp_fv0; + arg0->unkC = temp_fv0 * 0.5f; + arg0->unk0 = (arg1->m[2][1] - arg1->m[1][2]) * temp_fv1; + arg0->unk4 = (arg1->m[0][2] - arg1->m[2][0]) * temp_fv1; + arg0->unk8 = (arg1->m[1][0] - arg1->m[0][1]) * temp_fv1; + return; + } + var_v0 = 0; + if (arg1->m[0][0] < arg1->m[1][1]) { + var_v0 = 1; + } + if (arg1->m[var_v0][var_v0] < arg1->m[2][2]) { + var_v0 = 2; + } + switch (var_v0) { + case 0: + temp_fv0 = uvSqrtF((arg1->m[0][0] - (arg1->m[1][1] + arg1->m[2][2])) + 1.0f); + temp_fv1 = 0.5f / temp_fv0; + arg0->unk0 = temp_fv0 * 0.5f; + arg0->unk4 = (arg1->m[0][1] + arg1->m[1][0]) * temp_fv1; + arg0->unk8 = (arg1->m[2][0] + arg1->m[0][2]) * temp_fv1; + arg0->unkC = (arg1->m[2][1] - arg1->m[1][2]) * temp_fv1; + break; + case 1: + temp_fv0 = uvSqrtF((arg1->m[1][1] - (arg1->m[2][2] + arg1->m[0][0])) + 1.0f); + temp_fv1 = 0.5f / temp_fv0; + arg0->unk4 = temp_fv0 * 0.5f; + arg0->unk8 = (arg1->m[1][2] + arg1->m[2][1]) * temp_fv1; + arg0->unk0 = (arg1->m[0][1] + arg1->m[1][0]) * temp_fv1; + arg0->unkC = (arg1->m[0][2] - arg1->m[2][0]) * temp_fv1; + break; + case 2: + temp_fv0 = uvSqrtF((arg1->m[2][2] - (arg1->m[0][0] + arg1->m[1][1])) + 1.0f); + temp_fv1 = 0.5f / temp_fv0; + arg0->unk8 = temp_fv0 * 0.5f; + arg0->unk0 = (arg1->m[2][0] + arg1->m[0][2]) * temp_fv1; + arg0->unk4 = (arg1->m[1][2] + arg1->m[2][1]) * temp_fv1; + arg0->unkC = (arg1->m[1][0] - arg1->m[0][1]) * temp_fv1; + break; + } +} void _uvScDoneGfx(void) { OSScTask* scTask = D_802B9C60[D_802B9C6E]; diff --git a/src/kernel/sobj.c b/src/kernel/sobj.c index eb2191a..e833618 100644 --- a/src/kernel/sobj.c +++ b/src/kernel/sobj.c @@ -1,19 +1,303 @@ #include "common.h" +#include +#include +#include +#include -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/sobj/uvSobjsDraw.s") +extern s32 D_80248DD8; -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/sobj/func_8022C7B8.s") +void func_80215E7C(uvGfxUnkStructModel*); +void func_80214840(s16, f32*, f32*); +s32 func_80206F64(void*, f32, f32, f32, f32); +void _uvSortAdd(s32, f32, void*, UnkStruct_80204D94*, f32, f32, ...); -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/sobj/func_8022C8D0.s") +void uvSobjsDraw(UnkStruct_80204D94* arg0, Mtx4F* arg1, u16 arg2, u16 arg3, UnkSobjDraw* arg4, u16 arg5, u8 arg6, s32 arg7) { + UnkSobjDraw* var_s2; + f32 temp_fs0; + f32 temp_fs1; + f32 temp_fs2; + f32 temp_fv0; + u32 var_v0; + u8 var_s1; + uvGfxUnkStructModel* temp_s0; + uvGfxUnkStructModel** temp_fp; + f32 spB8; + f32 spB4; + f32 spB0; + f32 spAC; + f32 spA8; + s32 i; -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/sobj/func_8022CC28.s") + spB0 = arg0->unk1D0 - arg1->m[3][0]; + spAC = arg0->unk1D4 - arg1->m[3][1]; + spA8 = arg0->unk1D8 - arg1->m[3][2]; + func_80214840(arg6, &spB0, &spAC); -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/sobj/uvSobjLoadTerra.s") + temp_fp = gGfxUnkPtrs->unkC8; + for (i = 0; i < arg5; i++) { + var_s2 = &arg4[i]; -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/sobj/uvSobjPosm.s") + if (var_s2->unk0 == 0xFFFF) { + continue; + } -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/sobj/func_8022D168.s") + if (!(var_s2->unk14 & arg2)) { + continue; + } + temp_s0 = temp_fp[var_s2->unk0]; + if (temp_s0 == NULL) { + _uvDebugPrintf("uvSobjsDraw: model %d not in level\n"); + continue; + } -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/sobj/func_8022D1E4.s") + temp_fs1 = var_s2->unk8 - spB0; + temp_fs2 = var_s2->unkC - spAC; + temp_fs0 = var_s2->unk10 - spA8; + if (!(var_s2->unk14 & arg3)) { + spB8 = temp_fs1; + spB4 = temp_fs2; + func_80214840(arg6 * -1, &spB8, &spB4); + if (func_80206F64(arg0->unk2E0, spB8, spB4, temp_fs0, temp_s0->unk1C) == 0) { + continue; + } + } + temp_fv0 = uvSqrtF(SQ(temp_fs1) + SQ(temp_fs2) + SQ(temp_fs0)); + if (arg0->unk200 == 1.0f) { + var_s1 = var_v0 = func_8022C7B8(temp_s0, temp_fv0); + } else { + var_s1 = var_v0 = func_8022C7B8(temp_s0, arg0->unk200 * temp_fv0); + } + if (var_v0 == 0xFF) { + continue; + } + if (temp_s0->unk11 & 1) { + _uvSortAdd(4, temp_fv0, var_s2, arg0, arg1->m[3][0], arg1->m[3][1], temp_fs1, temp_fs2, arg1, arg7, var_s1); + } else if (temp_s0->unk8[var_v0].unk5 != 0) { + func_8022CC28(var_s2, temp_s0, var_s1, temp_fs1, temp_fs2); + } else { + func_8022C8D0(var_s2, temp_s0, var_s1, arg1); + } + } +} -#pragma GLOBAL_ASM("asm/nonmatchings/kernel/sobj/uvSobjModel.s") +u8 func_8022C7B8(uvGfxUnkStructModel* arg0, f32 arg1) { + s32 temp_v1; + s32 i; + f32* temp_v0; + + temp_v0 = arg0->unkC; + temp_v1 = arg0->unk10; + if (temp_v0[temp_v1 - 1] <= arg1) { + return 0xFF; + } + + for (i = temp_v1; i > 0; i--) { + if (temp_v0[i - 1] < arg1) { + return i; + } + } + return 0; +} + +void func_8022C8D0(UnkSobjDraw* arg0, uvGfxUnkStructModel* arg1, u8 arg2, Mtx4F* arg3) { + uvGfxUnkStruct8* temp_s3; + uvGfxUnkStruct10* temp_s2; + s32 temp_v0; + s32 i; + s32 j; + Mtx4F sp114; + Mtx4F spD4; + s32 pad; + Mtx sp90; + + temp_s3 = &arg1->unk8[arg2]; + + for (i = 0; i < temp_s3->unk4; i++) { + temp_s2 = &temp_s3->unk0[i]; + uvGfx_802235A4(arg0->unk4[i], 1); + if (temp_s2->unkD != 0) { + uvMat4CopyL2F(&sp114, arg0->unk4[i]); + sp114.m[3][0] += arg3->m[3][0]; + sp114.m[3][1] += arg3->m[3][1]; + sp114.m[3][2] += arg3->m[3][2]; + uvGfxLookAt(&sp114); + } + + for (j = 0; j < temp_s2->unk4; j++) { + uvGfxStateDraw(&temp_s2->unk0[j]); + } + if (i == temp_s3->unk4 - 1) { + break; + } + + for (j = 0; j <= temp_s3->unk0[i].unk6 - temp_s3->unk0[i + 1].unk6; j++) { + uvGfxMtxViewPop(); + } + } + temp_v0 = temp_s3->unk0[temp_s3->unk4 - 1].unk6; + for (i = 0; i <= temp_v0; i++) { + uvGfxMtxViewPop(); + } + if (D_80248DD8 != 0) { + uvMat4CopyL2F(&spD4, arg0->unk4[0]); + + uvMat4UnkOp3(&spD4, arg1->unk20, arg1->unk20, arg1->unk20); + uvMat4CopyF2L(&sp90, &spD4); + uvGfx_802235A4(sp90, 1); + func_80215E7C(arg1); + uvGfxMtxViewPop(); + } +} + +void func_8022CC28(UnkSobjDraw* arg0, uvGfxUnkStructModel* arg1, u8 arg2, f32 arg3, f32 arg4) { + uvMtx* temp_s6; + s32 temp_v1; + s32 i; + s32 j; + Mtx sp88; + f32 temp_fv0; + uvGfxUnkStruct10* temp_s2; + uvGfxUnkStruct10* temp_v0; + uvGfxUnkStruct8* temp_s4; + s32 pad; + f32 sp70; + + sp70 = arg1->unk20 / gGfxUnkPtrs->unk1608; + temp_s4 = &arg1->unk8[arg2]; + temp_s6 = (uvMtx*)arg0->unk4; + sp88.m[0][0] = temp_s6->m[0][0]; + sp88.m[0][2] = temp_s6->m[0][2]; + sp88.m[2][0] = temp_s6->m[2][0]; + sp88.m[2][2] = temp_s6->m[2][2]; + temp_fv0 = uvSqrtF(SQ(arg3) + SQ(arg4)); + + if (temp_fv0 != 0.0f) { + arg3 /= temp_fv0; + arg4 /= temp_fv0; + } + + temp_s6->u.i[0][0] = (s32)(((-arg4 / sp70) * 65536.0f) + 0.5f) >> 0x10; + temp_s6->u.i[0][1] = (s32)(((arg3 / sp70) * 65536.0f) + 0.5f) >> 0x10; + temp_s6->u.f[0][0] = (s32)(((-arg4 / sp70) * 65536.0f) + 0.5f) & 0xFFFF; + temp_s6->u.f[0][1] = (s32)(((arg3 / sp70) * 65536.0f) + 0.5f) & 0xFFFF; + temp_s6->u.i[1][1] = (s32)(((-arg4 / sp70) * 65536.0f) + 0.5f) >> 0x10; + temp_s6->u.i[1][0] = (s32)(((-arg3 / sp70) * 65536.0f) + 0.5f) >> 0x10; + temp_s6->u.f[1][1] = (s32)(((-arg4 / sp70) * 65536.0f) + 0.5f) & 0xFFFF; + temp_s6->u.f[1][0] = (s32)(((-arg3 / sp70) * 65536.0f) + 0.5f) & 0xFFFF; + + for (i = 0; i < temp_s4->unk4; i++) { + temp_s2 = &temp_s4->unk0[i]; + + uvGfx_802235A4(arg0->unk4[i], 1); + + for (j = 0; j < temp_s2->unk4; j++) { + uvGfxStateDraw(&temp_s2->unk0[j]); + } + // FAKE + if (temp_s4) { } + if (i == temp_s4->unk4 - 1) { + break; + } + + temp_v1 = temp_s4->unk0[i].unk6 - temp_s4->unk0[i + 1].unk6; + for (j = 0; j <= temp_v1; j++) { + uvGfxMtxViewPop(); + } + } + temp_v1 = temp_s4->unk0[temp_s4->unk4 - 1].unk6; + for (i = 0; i <= temp_v1; i++) { + uvGfxMtxViewPop(); + } + temp_s6->m[0][0] = sp88.m[0][0]; + temp_s6->m[0][2] = sp88.m[0][2]; + temp_s6->m[2][0] = sp88.m[2][0]; + temp_s6->m[2][2] = sp88.m[2][2]; +} + +UnkSobjDraw* uvSobjLoadTerra(u32 arg0) { + UnkSobjDraw* temp_a0; + uvGfxUnkStructTerra* temp_v0; + uvUnkTileStruct* temp_v1; + + temp_v0 = gGfxUnkPtrs->unk4[(arg0 >> 0x18) & 0xFF]; + if (temp_v0 == NULL) { + _uvDebugPrintf("Sobj: terra %d not in level\n", (arg0 >> 0x18) & 0xFF); + return NULL; + } + + temp_v1 = &temp_v0->unk28[(arg0 >> 0xC) & 0xFFF]; + if (temp_v1 == NULL) { + _uvDebugPrintf("Sobj: bad soid 0x%x, tile not found in terra\n", arg0); + return NULL; + } + + temp_a0 = &temp_v1->unk40->unk10[arg0 & 0xFFF]; + if (temp_a0 == NULL) { + _uvDebugPrintf("Sobj: bad soid, sobj %d not in terra %d, tile %d\n", (arg0 >> 0x18) & 0xFF, (arg0 >> 0xC) & 0xFFF, arg0 & 0xFFF); + return NULL; + } + return temp_a0; +} + +void uvSobjPosm(u32 arg0, s32 arg1, Mtx4F* arg2) { + UnkSobjDraw* temp_v0; + f32 temp_fa0; + f32 temp_fa1; + f32 temp_ft4; + + temp_v0 = uvSobjLoadTerra(arg0); + if (temp_v0 == NULL) { + return; + } + + temp_fa0 = arg2->m[3][0] / gGfxUnkPtrs->unk1608; + temp_fa1 = arg2->m[3][1] / gGfxUnkPtrs->unk1608; + temp_ft4 = arg2->m[3][2] / gGfxUnkPtrs->unk1608; + + if (arg1 == 0 && (FABS(temp_fa0 - temp_v0->unk8) > 0.01f || FABS(temp_fa1 - temp_v0->unkC) > 0.01f || FABS(temp_ft4 - temp_v0->unk10) > 0.01f)) { + _uvDebugPrintf("uvSobjPosm: warning, trying to translate part 0\n"); + _uvDebugPrintf(" new %f , %f , %f\n", temp_fa0, temp_fa1, temp_ft4); + _uvDebugPrintf(" old %f , %f , %f\n", temp_v0->unk8, temp_v0->unkC, temp_v0->unk10); + } else { + uvMat4CopyF2L(&temp_v0->unk4[arg1], arg2); + } +} + +void func_8022D168(u32 arg0, s32 arg1, Mtx4F* arg2) { + UnkSobjDraw* temp_v0; + + temp_v0 = uvSobjLoadTerra(arg0); + if (temp_v0 != NULL) { + uvMat4CopyL2F(arg2, temp_v0->unk4[arg1]); + } +} + +u16 func_8022D1E4(u32 arg0) { + UnkSobjDraw* temp_v0; + + temp_v0 = uvSobjLoadTerra(arg0); + if (temp_v0 == NULL) { + return 0xFFFF; + } + return temp_v0->unk0; +} + +void uvSobjModel(u32 arg0, s32 arg1) { + UnkSobjDraw* temp_v0; + uvGfxUnkStructModel* temp_v1; + + temp_v0 = uvSobjLoadTerra(arg0); + if (temp_v0 == NULL) { + return; + } + temp_v1 = gGfxUnkPtrs->unkC8[arg1]; + if (temp_v1 == NULL) { + _uvDebugPrintf("uvSobjModel: model %d not in level\n", arg1); + return; + } + if (temp_v1->unk8->unk4 != gGfxUnkPtrs->unkC8[temp_v0->unk0]->unk8->unk4) { + _uvDebugPrintf("uvSobjModel: new model %d had different heirarchy\n", arg1); + return; + } + temp_v0->unk0 = arg1; +} diff --git a/src/kernel/sprite.c b/src/kernel/sprite.c index 8f78cad..8b306a0 100644 --- a/src/kernel/sprite.c +++ b/src/kernel/sprite.c @@ -76,7 +76,7 @@ void uvSprt_802301A4(void) { void _uvTxtDraw(s32 textureId) { unk_UVTX_1C* temp_a1; - uvGfxUnkStruct2* temp_a2; + uvGfxUnkStructTexture* temp_a2; s32 temp_a3; s32 temp_t1; s32 temp_ft1; @@ -123,7 +123,7 @@ void _uvTxtDraw(s32 textureId) { } } -void uvSprtFromBitmap(uvSprite_t* arg0, uvGfxUnkStruct2* arg1) { +void uvSprtFromBitmap(uvSprite_t* arg0, uvGfxUnkStructTexture* arg1) { if (arg0->textureId == 0xFFFF) { _uvDebugPrintf("Warning: Bitmap sprite switched to texture sprite w/o uvMemReset\n"); arg0->bitmap = NULL; @@ -144,7 +144,7 @@ void uvSprtFromBitmap(uvSprite_t* arg0, uvGfxUnkStruct2* arg1) { arg0->bitmap->LUToffset = 0; } -void uvSprt_80230750(uvSprite_t* arg0, uvGfxUnkStruct2* arg1) { +void uvSprt_80230750(uvSprite_t* arg0, uvGfxUnkStructTexture* arg1) { Sprite* sprite = &arg0->sprite; if (arg1 != NULL) { @@ -293,7 +293,7 @@ void uvSprtDraw(s32 sprite_id) { } void uvSprtSetBlit(uvSprite_t* arg0, s32 arg1) { - uvGfxUnkStruct1410* var_v1; + uvGfxUnkStructBlit* var_v1; Sprite* sprite = &arg0->sprite; var_v1 = gGfxUnkPtrs->unk1410[arg1]; @@ -385,7 +385,7 @@ s16 uvSprtGetHeight(s32 sprite_id) { } void uvSprtProps(s32 sprite_id, ...) { - uvGfxUnkStruct2* temp_s2; + uvGfxUnkStructTexture* temp_s2; uvSprite_t* temp_s1; va_list args; s32 token;