BEEG functions, m2ctx removed

include/game/hsfanim.h

@@ -0,0 +1,13 @@
+#ifndef GAME_HSFANIM_H
+#define GAME_HSFANIM_H
+
+#include "common.h"
+#include "game/sprite.h"
+
+typedef struct particle_data {
+    char unk_00[0x44];
+    AnimData *unk_44;
+    char unk_48[0x10];
+} ParticleData;
+
+#endif

include/game/hsfman.h

@@ -3,35 +3,43 @@
 
 #include "common.h"
 #include "game/memory.h"
+#include "game/hsfanim.h"
 #include "game/hsfformat.h"
 #include "game/sprite.h"
 
 typedef struct model_data {
     u8 unk_00;
     u8 unk_01;
-    s16 unk_02;
+    s8 unk_02;
-    s16 unk_04;
+    s8 unk_03;
+    s8 unk_04;
+    s8 unk_05;
     s16 unk_06;
     s16 unk_08;
     s16 unk_0A;
     s16 unk_0C;
     s16 unk_0E;
-    char unk_10[0x12];
+    s16 unk_10[4];
+    char unk_18[0x8];
+    s16 unk_20;
     u16 unk_22;
-    char unk_24[0x24];
+    s16 unk_24;
-    u32 unk_48;
+    s16 unk_26;
-    char unk_4C[0x4];
+    char unk_28[0x10];
+    s16 unk_38[8];
+    HsfData *unk_48;
+    HsfData *unk_4C;
     u32 unk_50;
     u32 unk_54;
-    char unk_58[0xC];
+    Point3d unk_58;
     f32 unk_64;
-    char unk_68[0xC];
+    Point3d unk_68;
     f32 unk_74;
     char unk_78[0x1C];
     f32 unk_94;
     char unk_98[0x2C];
     HsfData *hsfData;
-    char unk_C8[0x4];
+    HsfData *unk_C8;
     f32 unk_CC;
     f32 unk_D0;
     f32 unk_D4;
@@ -41,9 +49,10 @@ typedef struct model_data {
     f32 unk_E4;
     f32 unk_E8;
     f32 unk_EC;
-    f32 unk_F0[3][4];
+    Mtx unk_F0;
-    char unk_120[0x4];
+    ParticleData *unk_120;
 } ModelData;
+
 typedef struct ThreeDCameraStruct {
     f32 unk_00;
     f32 start;
@@ -61,25 +70,93 @@ typedef struct ThreeDProjectionStruct {
     Mtx unk_38;
     char unk_68[0x30];
 } ThreeDProjectionStruct;
-typedef struct ThreeDShadowStruct {
+typedef struct shadow_data {
     char unk_00[0x2];
     u16 unk_02;
     void*unk_04;
     char unk_08[0x90];
-} ThreeDShadowStruct;
+} ShadowData;
-typedef struct fog_data {
+typedef struct motion_data {
-    GXFogType fogType;
+    s16 unk_00;
-    f32 start;
+    s16 unk_02;
-    f32 end;
+    HsfData *unk_04;
-    GXColor color;
+} MotionData;
-} FogStruct;
+typedef struct light_data {
+    char unk_00[0x44];
+} LightData;
+
+void ClusterMotionExec(ModelData*);             /* extern */
+void ClusterProc(ModelData*);                   /* extern */
+void EnvelopeProc(HsfData*);                           /* extern */
+void GXWaitDrawDone();                                 /* extern */
+void Hu3DAnimExec();                                   /* extern */
+void Hu3DCameraMotionExec(s16);                        /* extern */
+void Hu3DCameraSet(s16, void*);                        /* extern */
+void Hu3DDraw(ModelData*, f32*, f32*);          /* extern */
+void Hu3DDrawPost();                                   /* extern */
+void Hu3DDrawPreInit();                                /* extern */
+void Hu3DMotionNext(s16);                              /* extern */
+void Hu3DShadowExec();                                 /* extern */
+void Hu3DSubMotionExec(s16);                           /* extern */
+void HuPerfBegin(s32);                                   /* extern */
+void HuPerfEnd(s32);                                     /* extern */
+void HuSprBegin(void);                                     /* extern */
+void HuSprDispInit(void);                                  /* extern */
+void HuSprExec(s16);                                     /* extern */
+void HuSprFinish(void);                                    /* extern */
+void InitVtxParm(HsfData*);                            /* extern */
+void ShapeProc(HsfData*);                              /* extern */
+void mtxRot(Mtx, f32, f32, f32);                /* extern */
+void mtxScaleCat(Mtx, f32, f32, f32);           /* extern */
+void mtxTransCat(Mtx, f32, f32, f32);
+void Hu3DAnimInit(void);
+void Hu3DFogClear(void);
+void Hu3DLighInit(void);
+void Hu3DMotionInit(void);
+void Hu3DParManInit(void);
+void Hu3DFogSet(f32, f32, u8, u8, u8);                 /* extern */
+void Hu3DMotionClusterSet(s16, s16);                   /* extern */
+void Hu3DMotionExec(s16, s16, f32, s32);
+f32 Hu3DMotionMaxTimeGet(s16);                      /* extern */
+s16 Hu3DMotionModelCreate(s16);                     /* extern */
+void Hu3DMotionShapeSet(s16, s16);                     /* extern */
+HsfData* LoadHSF(s32);                              /* extern */
+void MakeDisplayList(s16, HsfData*);                   /* extern */
+void ClusterAdjustObject(HsfData*, HsfData*);          /* extern */
+HsfObject* Hu3DObjDuplicate(HsfData*, u32);         /* extern */
+void Hu3DAnimModelKill(s16);                           /* extern */
+void Hu3DGLightKill(s16);                              /* extern */
+void Hu3DLLightKill(s16, s16);                         /* extern */
+s32 Hu3DMotionKill(s16);
 
 void Hu3DInit(void);
 void Hu3DPreProc(void);
 void Hu3DExec(void);
+void Hu3DAllKill(void);
+void Hu3DBGColorSet(u8, u8, u8);
+void Hu3DLayerHookSet(s16, void (*)(s16));
+void Hu3DPauseSet(s32);
+void Hu3DNoSyncSet(s32);
+s16 Hu3DModelCreate(s32);
+s16 Hu3DModelLink(s16);
+s16 Hu3DHookFuncCreate(HsfData*);
 void Hu3DShadowSizeSet(u16);
 void Hu3DProjectionKill(s16);
 void Hu3DProjectionPosSet(s16, Vec, Vec, Vec);
 void Hu3DProjectionTPLvlSet(s16, f32);
 void Hu3DMipMapSet(char*, s16, s32, f32);
+
+extern MotionData Hu3DMotion[0x100];
+extern f32 lbl_801D4AB0;
+extern f32 lbl_801D4AB4;
+extern f32 lbl_801D4AB8;
+extern f32 lbl_801D4AFC;
+extern GXColor lbl_801D6BE0;
+extern u32 totalMatCnt;
+extern u32 totalMatCnted;
+extern u32 totalPolyCnt;
+extern u32 totalTexCacheCnt;
+extern u32 totalTexCacheCnted;
+extern u32 totalTexCnt;
+extern u32 totalTexCnted;
 #endif

src/game/hsfman.c

@@ -1,30 +1,33 @@
 #include "game/hsfman.h"
 
-void Hu3DAnimInit(void);
+ModelData Hu3DData[0x200];
-void Hu3DFogClear(void);
+ThreeDCameraStruct Hu3DCamera[0x10];
-void Hu3DLighInit(void);
+s16 layerNum[8];
-void Hu3DMotionInit(void);
+void (*layerHook[8])(s16);
-void Hu3DParManInit(void);
+AnimData *reflectAnim[5];
-
+AnimData *hiliteAnim[4];
-s16 Hu3DCameraExistF;
+ThreeDProjectionStruct Hu3DProjection[4];
-ModelData Hu3DData[0x200] = {};
+ShadowData Hu3DShadowData;
-ThreeDCameraStruct Hu3DCamera[0x10] = {};
+HsfScene FogData;
-s16 layerNum[8] = {};
+Mtx Hu3DCameraMtx;
-void (*layerHook[8])(s16) = {};
+LightData Hu3DGlobalLight[0x8];
-AnimData *reflectAnim[5] = {};
+Mtx Hu3DCameraMtxXPose;
-AnimData *hiliteAnim[4] = {};
+LightData Hu3DLocalLight[0x20];
-ThreeDProjectionStruct Hu3DProjection[4] = {};
+GXColor BGColor;
-ThreeDShadowStruct Hu3DShadowData = {};
+s16 reflectMapNo;
-HsfScene FogData = {};
+AnimData *toonAnim;
-Mtx Hu3DCameraMtx = {};
-Mtx Hu3DCameraMtxXPose = {};
-s16 Hu3DPauseF;
-s16 Hu3DProjectionNum;
 s16 Hu3DShadowCamBit;
 s32 Hu3DShadowF;
+s32 shadowModelDrawF;
+s16 Hu3DProjectionNum;
+s16 Hu3DCameraNo;
+s16 Hu3DCameraBit;
+HsfData* Hu3DMallocNo;
+s16 Hu3DPauseF;
+s16 Hu3DCameraExistF;
 u16 NoSyncF;
-f32 lbl_801D4AB0;
 s32 modelKillAllF;
+
 #include "refMapData0.inc"
 #include "refMapData1.inc"
 #include "refMapData2.inc"
@@ -36,24 +39,6 @@ s32 modelKillAllF;
 #include "hiliteData2.inc"
 #include "hiliteData3.inc"
 #include "hiliteData4.inc"
-const char lbl_8012D630[] = "Error: Not Found %s for MipMapSet\n";
-s16 reflectMapNo;
-AnimData *toonAnim;
-GXColor BGColor;
-
-extern s16 Hu3DCameraBit;
-extern s16 Hu3DCameraNo;
-extern f32 lbl_801D4AB4;
-extern f32 lbl_801D4AFC;
-extern GXColor lbl_801D6BE0;
-extern s32 shadowModelDrawF;
-extern u32 totalMatCnt;
-extern u32 totalMatCnted;
-extern u32 totalPolyCnt;
-extern u32 totalTexCacheCnt;
-extern u32 totalTexCacheCnted;
-extern u32 totalTexCnt;
-extern u32 totalTexCnted;
 
 void Hu3DInit(void) {
     ModelData* data;
@@ -283,6 +268,339 @@ void Hu3DExec(void) {
     HuPerfEnd(3);
 }
 
+void Hu3DAllKill(void) {
+    s16 i;
+    Hu3DModelAllKill();
+    Hu3DMotionAllKill();
+    Hu3DCameraAllKill();
+    Hu3DLightAllKill();
+    Hu3DAnimAllKill();
+    if(reflectAnim[0] != (AnimData *)refMapData0) {
+        HuMemDirectFree(reflectAnim[0]);
+    }
+    reflectAnim[0] = HuSprAnimRead(refMapData0);
+    if(Hu3DShadowData.unk_04) {
+        HuMemDirectFree(Hu3DShadowData.unk_04);
+        Hu3DShadowCamBit = 0;
+        Hu3DShadowData.unk_04 = NULL;
+        Hu3DShadowF = 0;
+    }
+    Hu3DFogClear();
+    for(i=0; i<8; i++) {
+        layerNum[i] = 0;
+        layerHook[i] = NULL;
+    }
+    for(i=0; i<4; i++) {
+        if(Hu3DProjection[i].unk_04) {
+            Hu3DProjectionKill(i);
+        }
+        Hu3DProjection[i].unk_04 = NULL;
+    }
+    NoSyncF = 0;
+}
+
+void Hu3DBGColorSet(u8 arg0, u8 arg1, u8 arg2) {
+    BGColor.r = arg0;
+    BGColor.g = arg1;
+    BGColor.b = arg2;
+}
+
+void Hu3DLayerHookSet(s16 layer, void (*func)(s16)) {
+    layerHook[layer] = func;
+}
+
+void Hu3DPauseSet(s32 arg0) {
+    Hu3DPauseF = arg0;
+}
+
+void Hu3DNoSyncSet(s32 arg0) {
+    NoSyncF = arg0;
+}
+
+s16 Hu3DModelCreate(s32 arg0) {
+    HsfData* temp_r0;
+    ModelData* var_r31;
+    s16 i;
+    s16 var_r30;
+
+    var_r31 = Hu3DData;
+    
+    for (var_r30 = 0; var_r30 < 0x200; var_r30++, var_r31++) {
+        if (var_r31->hsfData == 0x0) {
+            break;
+        }
+    }
+    if (var_r30 == 0x200) {
+        OSReport("Error: Not Found %s for MipMapSet\n");
+        return -1;
+    }
+    var_r31->hsfData = LoadHSF(arg0);
+    var_r31->unk_48 = Hu3DMallocNo = var_r31->hsfData;
+    var_r31->unk_50 = 0;
+    var_r31->unk_54 = 0;
+    var_r31->unk_02 = 0;
+    MakeDisplayList(var_r30, (HsfData* ) var_r31->unk_48);
+    var_r31->unk_68.x = lbl_801D4AB8;
+    for (i = 0; i < 4; i++) {
+        var_r31->unk_10[i] = -1;
+    }
+    var_r31->unk_0A = -1;
+    var_r31->unk_0C = -1;
+    var_r31->unk_0E = -1;
+    var_r31->unk_64 = lbl_801D4AB4;
+    if (var_r31->hsfData->motionCnt != 0) {
+        var_r31->unk_08 = var_r31->unk_20 = Hu3DMotionModelCreate(var_r30);
+        if (var_r31->hsfData->cenvCnt != 0) {
+            Hu3DMotionExec(var_r30, var_r31->unk_08, lbl_801D4AB4, 0);
+            EnvelopeProc(var_r31->hsfData);
+            PPCSync();
+        }
+        if (var_r31->hsfData->clusterCnt != 0) {
+            Hu3DMotionClusterSet(var_r30, var_r31->unk_08);
+        }
+        if (var_r31->hsfData->shapeCnt != 0) {
+            Hu3DMotionShapeSet(var_r30, var_r31->unk_08);
+        }
+        var_r31->unk_68.y = lbl_801D4AB4;
+        var_r31->unk_68.z = Hu3DMotionMaxTimeGet(var_r30);
+    } else {
+        var_r31->unk_20 = var_r31->unk_08 = -1;
+    }
+    var_r31->unk_CC = var_r31->unk_D0 = var_r31->unk_D4 = lbl_801D4AB4;
+    var_r31->unk_D8 = var_r31->unk_DC = var_r31->unk_E0 = lbl_801D4AB4;
+    var_r31->unk_E4 = var_r31->unk_E8 = var_r31->unk_EC = lbl_801D4AB8;
+    var_r31->unk_22 = -1;
+    var_r31->unk_06 = 0;
+    var_r31->unk_120 = 0;
+    var_r31->unk_26 = 0;
+    var_r31->unk_03 = 0;
+    var_r31->unk_58.x = var_r31->unk_58.z = var_r31->unk_58.y = lbl_801D4AB8;
+    var_r31->unk_04 = -1;
+    var_r31->unk_24 = -1;
+    
+    for (i = 0; i < 8; i++) {
+        var_r31->unk_38[i] = -1;
+    }
+    var_r31->unk_01 = 0;
+    var_r31->unk_00 = (u8) var_r30;
+    PSMTXIdentity(var_r31->unk_F0);
+    layerNum[0] += 1;
+    HuMemDCFlush(HEAP_DATA);
+    if ((var_r31->hsfData->sceneCnt != 0) && ((var_r31->hsfData->scene->start != lbl_801D4AB4) || (var_r31->hsfData->scene->end != lbl_801D4AB4))) {
+        Hu3DFogSet(var_r31->hsfData->scene->start, var_r31->hsfData->scene->end, var_r31->hsfData->scene->color.r, var_r31->hsfData->scene->color.g, var_r31->hsfData->scene->color.b);
+    }
+    return var_r30;
+}
+
+s16 Hu3DModelLink(s16 arg0) {
+    HsfObject* temp_r3_2;
+    ModelData* temp_r30;
+    ModelData* var_r31;
+    s16 var_r28;
+    s16 i;
+    s32 temp_r0;
+    s32 temp_r3;
+    s32 temp_r5;
+    s32 var_ctr;
+    HsfData* var_r4;
+    HsfData* var_r5;
+
+    temp_r30 = &Hu3DData[arg0];
+    var_r31 = Hu3DData;
+    for (var_r28 = 0; var_r28 < 0x200; var_r28++, var_r31++) {
+        if (var_r31->hsfData == 0x0) {
+            break;
+        }
+    }
+    if (var_r28 == 0x200) {
+        return -1;
+    }
+    var_r31->unk_C8 = temp_r30->hsfData;
+    var_r31->hsfData = HuMemDirectMallocNum(HEAP_DATA, 0x80, (u32)var_r31->unk_4C);
+    var_r31->unk_4C = var_r31->hsfData;
+    *var_r31->hsfData = *temp_r30->hsfData;
+    temp_r3_2 = Hu3DObjDuplicate(var_r31->hsfData, (u32)var_r31->unk_4C);
+    var_r31->hsfData->root = (HsfObject*)((u32)temp_r3_2 + ((u32)var_r31->hsfData->root - (u32)var_r31->hsfData->object));
+    var_r31->hsfData->object = temp_r3_2;
+    var_r31->unk_48 = temp_r30->unk_48;
+    var_r31->unk_50 = temp_r30->unk_50;
+    temp_r30->unk_50 |= 0x100000;
+    var_r31->unk_54 = temp_r30->unk_54;
+    var_r31->unk_CC = var_r31->unk_D0 = var_r31->unk_D4 = lbl_801D4AB4;
+    var_r31->unk_D8 = var_r31->unk_DC = var_r31->unk_E0 = lbl_801D4AB4;
+    var_r31->unk_E4 = var_r31->unk_E8 = var_r31->unk_EC = lbl_801D4AB8;
+    var_r31->unk_08 = temp_r30->unk_08;
+    if (var_r31->unk_08 != -1) {
+        var_r31->unk_68.y = lbl_801D4AB4;
+        var_r31->unk_68.z = Hu3DMotionMaxTimeGet(var_r28);
+    }
+    var_r31->unk_0C = var_r31->unk_0A = var_r31->unk_0E = -1;
+    for (i = 0; i < 4; i++) {
+        var_r31->unk_10[i] = temp_r30->unk_10[i];
+        if (var_r31->unk_10[i] != -1) {
+            ClusterAdjustObject(var_r31->hsfData, Hu3DMotion[var_r31->unk_10[i]].unk_04);
+            var_r31->unk_50 |= 0x400;
+        }
+    }
+    var_r31->unk_64 = temp_r30->unk_64;
+    var_r31->unk_68.x = temp_r30->unk_68.x;
+    var_r31->unk_20 = temp_r30->unk_20;
+    var_r31->unk_22 = -1;
+    var_r31->unk_06 = 0;
+    var_r31->unk_120 = 0;
+    var_r31->unk_26 = 0;
+    var_r31->unk_03 = 0;
+    var_r31->unk_02 = 0;
+    var_r31->unk_58.x = var_r31->unk_58.z = var_r31->unk_58.y = lbl_801D4AB8;
+    var_r31->unk_04 = -1;
+    var_r31->unk_24 = arg0;
+    for (i = 0; i < 8; i++) {
+        var_r31->unk_38[i] = -1;
+    }
+    var_r31->unk_01 = 0;
+    PSMTXIdentity(var_r31->unk_F0);
+    layerNum[0] += 1;
+    return var_r28;
+}
+
+s16 Hu3DHookFuncCreate(HsfData* arg0) {
+    HsfData* sp8;
+    ModelData* var_r31;
+    s16 var_r29;
+    s16 i;
+
+    var_r31 = Hu3DData;
+    for (var_r29 = 0; var_r29 < 0x200; var_r29++, var_r31++) {
+        if (var_r31->hsfData == 0) {
+            break;
+        }
+    }
+    if (var_r29 == 0x200) {
+        return -1;
+    }
+    var_r31->hsfData = arg0;
+    var_r31->unk_48 = (HsfData *)(var_r29 + 0x2710);
+    var_r31->unk_50 = 0x10;
+    var_r31->unk_54 = 0;
+    var_r31->unk_CC = var_r31->unk_D0 = var_r31->unk_D4 = lbl_801D4AB4;
+    var_r31->unk_D8 = var_r31->unk_DC = var_r31->unk_E0 = lbl_801D4AB4;
+    var_r31->unk_E4 = var_r31->unk_E8 = var_r31->unk_EC = lbl_801D4AB8;
+    var_r31->unk_08 = var_r31->unk_0C = var_r31->unk_0A = var_r31->unk_0E = -1;
+    
+    for (i = 0; i < 4; i++) {
+        var_r31->unk_10[i] = -1;
+    }
+    var_r31->unk_64 = lbl_801D4AB4;
+    var_r31->unk_68.x = lbl_801D4AB8;
+    var_r31->unk_20 = -1;
+    var_r31->unk_22 = -1;
+    var_r31->unk_06 = 0;
+    var_r31->unk_120 = 0;
+    var_r31->unk_26 = 0;
+    var_r31->unk_03 = 0;
+    var_r31->unk_24 = -1;
+    var_r31->unk_02 = 0;
+    var_r31->unk_04 = -1;
+    
+    for (i = 0; i < 8; i++) {
+        var_r31->unk_38[i] = -1;
+    }
+    var_r31->unk_01 = 0;
+    PSMTXIdentity(var_r31->unk_F0);
+    layerNum[0] += 1;
+    return var_r29;
+}
+
+void Hu3DModelKill(s16 arg0) {
+    HsfData* var_r28;
+    ModelData* temp_r31;
+    ModelData* var_r30;
+    ParticleData *copy;
+    s16 var_r27;
+    s16 i;
+
+    temp_r31 = &Hu3DData[arg0];
+    var_r28 = temp_r31->hsfData;
+    if (var_r28 != 0) {
+        if ((temp_r31->unk_50 & 4) != 0) {
+            Hu3DShadowCamBit -= 1;
+        }
+        layerNum[temp_r31->unk_06] -= 1;
+
+        if ((temp_r31->unk_50 & 0x10) != 0) {
+            HuMemDirectFreeNum(HEAP_DATA, (u32) temp_r31->unk_48);
+            if ((temp_r31->unk_50 & 0x20) != 0) {
+                copy = temp_r31->unk_120;
+                HuSprAnimKill(copy->unk_44);
+            }
+            temp_r31->hsfData = NULL;
+            if (modelKillAllF == 0) {
+                HuMemDCFlush(HEAP_DATA);
+            }
+            return;
+        }
+        if ((temp_r31->unk_50 & 0x10000) != 0) {
+            if (temp_r31->unk_08 != -1) {
+                Hu3DMotionKill(temp_r31->unk_08);
+            }
+            HuMemDirectFreeNum(HEAP_DATA, (u32) temp_r31->unk_48);
+            temp_r31->hsfData = NULL;
+            return;
+        }
+        Hu3DAnimModelKill(arg0);
+        if (temp_r31->unk_24 != -1) {
+            HuMemDirectFree(temp_r31->hsfData);
+            HuMemDirectFreeNum(HEAP_DATA, (u32) temp_r31->unk_4C);
+            var_r28 = temp_r31->unk_C8;
+            temp_r31->hsfData = var_r28;
+        }
+        var_r30 = Hu3DData;
+        for (var_r27 = i = 0; i < 0x200; i++, var_r30++) {
+            if ((var_r30->hsfData != 0) && (var_r30->hsfData == var_r28 || (var_r30->unk_24 != -1 && var_r30->unk_C8 == var_r28))) {
+                var_r27++;
+            }
+        }
+        if (var_r27 > 1) {
+            temp_r31->hsfData = NULL;
+            var_r30 = Hu3DData;
+            if (temp_r31->unk_20 != -1) {
+                for (i = 0; i < 0x200; i++, var_r30++) {
+                    if (var_r30->hsfData != 0 && var_r30->unk_24 != -1 && var_r30->unk_C8 == var_r28) {
+                        Hu3DMotion[temp_r31->unk_20].unk_02 = i;
+                        break;
+                    }
+                }
+            }
+            if (modelKillAllF == 0) {
+                HuMemDCFlush(HEAP_DATA);
+            }
+            return;
+        }
+        if (temp_r31->unk_20 != -1 && Hu3DMotionKill(temp_r31->unk_20) == 0) {
+            Hu3DMotion[temp_r31->unk_20].unk_02 = -1;
+            HuMemDirectFreeNum(HEAP_DATA, (u32) temp_r31->unk_48);
+            temp_r31->hsfData = NULL;
+            if (modelKillAllF == 0) {
+                HuMemDCFlush(HEAP_DATA);
+            }
+            return;
+        }
+        HuMemDirectFree(temp_r31->hsfData);
+        HuMemDirectFreeNum(HEAP_DATA, (u32) temp_r31->unk_48);
+        for (i = 0; i < temp_r31->unk_26; i++) {
+            Hu3DGLightKill(temp_r31->unk_28[i]);
+        }
+        for (i = 0; i < 8; i++) {
+            if (temp_r31->unk_38[i] != -1) {
+                Hu3DLLightKill(arg0, i);
+            }
+        }
+        temp_r31->hsfData = NULL;
+        if (modelKillAllF == 0) {
+            HuMemDCFlush(HEAP_DATA);
+        }
+    }
+}
 
 void Hu3DShadowSizeSet(u16 arg0) {
     Hu3DShadowData.unk_02 = arg0;
@@ -328,7 +646,7 @@ void Hu3DMipMapSet(char* arg0, s16 arg1, s32 arg2, f32 arg8) {
         }
     }
     if (i == temp_r27->attributeCnt) {
-        OSReport(lbl_8012D630, arg2);
+        OSReport("Error: Not Found %s for MipMapSet\n", arg2);
         return;
     }
     temp_r31 = var_r26->bitmap;
@@ -337,7 +655,7 @@ void Hu3DMipMapSet(char* arg0, s16 arg1, s32 arg2, f32 arg8) {
     for ( i = 0, var_r24 = i; i < temp_r3->bmpNum; i++, var_r30++) {
         var_r24 += var_r30->dataSize;
     }
-    var_r23 = HuMemDirectMallocNum(HEAP_DATA, var_r24, temp_r25->unk_48);
+    var_r23 = HuMemDirectMallocNum(HEAP_DATA, var_r24, (u32)temp_r25->unk_48);
     temp_r22 = var_r23;
     var_r30 = temp_r3->bmp;
     temp_r31->data = temp_r22;

tools/m2ctx.py

@@ -1,73 +0,0 @@
-#!/usr/bin/env python3
-
-import argparse
-import os
-import sys
-import subprocess
-import tempfile
-
-script_dir = os.path.dirname(os.path.realpath(__file__))
-root_dir = os.path.abspath(os.path.join(script_dir, ".."))
-src_dir = root_dir + "src/"
-
-# Project-specific
-CPP_FLAGS = [
-    "-Iinclude",
-    "-Isrc",
-    "-Ibuild/include",
-    "-Iinclude/engine",
-    "-D_LANGUAGE_C",
-    "-DF3DEX_GBI_2",
-    "-D_MIPS_SZLONG=32",
-    "-D__attribute__(...)=",
-    "-D__asm__(...)=",
-    "-ffreestanding",
-    "-DM2CTX",
-]
-
-def import_c_file(in_file) -> str:
-    in_file = os.path.relpath(in_file, root_dir)
-    cpp_command = ["gcc", "-E", "-P", "-dM", *CPP_FLAGS, in_file]
-    cpp_command2 = ["gcc", "-E", "-P", *CPP_FLAGS, in_file]
-
-    with tempfile.NamedTemporaryFile(suffix=".c") as tmp:
-        stock_macros = subprocess.check_output(["gcc", "-E", "-P", "-dM", tmp.name], cwd=root_dir, encoding="utf-8")
-
-    out_text = ""
-    try:
-        out_text += subprocess.check_output(cpp_command, cwd=root_dir, encoding="utf-8")
-        out_text += subprocess.check_output(cpp_command2, cwd=root_dir, encoding="utf-8")
-    except subprocess.CalledProcessError:
-        print(
-            "Failed to preprocess input file, when running command:\n"
-            + ' '.join(cpp_command),
-            file=sys.stderr,
-            )
-        sys.exit(1)
-
-    if not out_text:
-        print("Output is empty - aborting")
-        sys.exit(1)
-
-    for line in stock_macros.strip().splitlines():
-        out_text = out_text.replace(line + "\n", "")
-    return out_text
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="""Create a context file which can be used for mips_to_c"""
-    )
-    parser.add_argument(
-        "c_file",
-        help="""File from which to create context""",
-    )
-    args = parser.parse_args()
-
-    output = import_c_file(args.c_file)
-
-    with open(os.path.join(root_dir, "ctx.c"), "w", encoding="UTF-8") as f:
-        f.write(output)
-
-
-if __name__ == "__main__":
-    main()