Merge pull request #45 from abnormalhare/main

Big HSFman Update

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,47 +3,50 @@
 
 #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;
-    s16 unk_06;
+    s8 unk_04;
+    s8 unk_05;
+    s16 layer;
     s16 unk_08;
     s16 unk_0A;
     s16 unk_0C;
     s16 unk_0E;
-    char unk_10[0x12];
+    s16 unk_10[4];
-    u16 unk_22;
+    s16 cluster_attr[4];
-    char unk_24[0x24];
+    s16 unk_20;
-    u32 unk_48;
+    u16 camera;
-    char unk_4C[0x4];
+    s16 unk_24;
-    u32 unk_50;
+    s16 unk_26;
-    u32 unk_54;
+    char unk_28[0x10];
-    char unk_58[0xC];
+    s16 unk_38[8];
+    HsfData *unk_48;
+    HsfData *unk_4C;
+    u32 attr;
+    u32 motion_attr;
+    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;
+    Vec pos;
-    f32 unk_D0;
+    Vec rot;
-    f32 unk_D4;
+    Vec scale;
-    f32 unk_D8;
+    Mtx unk_F0;
-    f32 unk_DC;
+    ParticleData *unk_120;
-    f32 unk_E0;
-    f32 unk_E4;
-    f32 unk_E8;
-    f32 unk_EC;
-    f32 unk_F0[3][4];
-    char unk_120[0x4];
 } ModelData;
+
 typedef struct ThreeDCameraStruct {
     f32 unk_00;
     f32 start;
@@ -61,11 +64,113 @@ 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 motion_data {
+    s16 unk_00;
+    s16 unk_02;
+    HsfData *unk_04;
+} MotionData;
+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 Hu3DModelKill(s16);
+void Hu3DParManAllKill(void);
+s32 MakeObjectName(s32);
+
+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 Hu3DModelAllKill(void);
+void Hu3DModelPosSet(s16, f32, f32, f32);
+void Hu3DModelPosSetV(s16, Vec);
+void Hu3DModelRotSet(s16, f32, f32, f32);
+void Hu3DModelRotSetV(s16, Vec);
+void Hu3DModelScaleSet(s16, f32, f32, f32);
+void Hu3DModelScaleSetV(s16, Vec);
+void Hu3DModelAttrSet(s16, u32);
+void Hu3DModelAttrReset(s16, u32);
+u32 Hu3DModelAttrGet(s16);
+u32 Hu3DModelMotionAttrGet(s16);
+void Hu3DModelClusterAttrSet(s16, s16, s32);
+void Hu3DModelClusterAttrReset(s16, s16, s32);
+void Hu3DModelCameraSet(s16, u16);
+void Hu3DModelLayerSet(s16, s16);
+HsfObject* Hu3DModelObjPtrGet(s16, s32);
+//...
+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,30 +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;
-void Hu3DAnimInit(void);
-void Hu3DFogClear(void);
-void Hu3DLighInit(void);
-void Hu3DMotionInit(void);
-void Hu3DParManInit(void);
-
-
-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;
@@ -121,7 +100,7 @@ void Hu3DPreProc(void) {
     var_r31 = &Hu3DData[0];
     for (var_r30 = 0; var_r30 < 0x200; var_r31++) {
         if (var_r31->hsfData != 0) {
-            var_r31->unk_50 &= 0xFFFFF7FF;
+            var_r31->attr &= 0xFFFFF7FF;
         }
         var_r30++;
     }
@@ -200,16 +179,16 @@ void Hu3DExec(void) {
                     var_r30 = Hu3DData;
                     for (i = 0, var_r23 = i; i < 0x200; i++, var_r30++) {
                         if (var_r30->hsfData != 0) {
-                            if ((var_r30->unk_50 & 0x10000) != 0) {
+                            if ((var_r30->attr & 0x10000) != 0) {
                                 Hu3DCameraMotionExec(i);
                             } else {
-                                if ((var_r30->unk_50 & 0x2001) == 0x2001 && var_r30->unk_08 != -1) {
+                                if ((var_r30->attr & 0x2001) == 0x2001 && var_r30->unk_08 != -1) {
                                     Hu3DMotionExec(i, var_r30->unk_08, var_r30->unk_64, 0);
                                 }
-                                if ((var_r30->unk_50 & 9) == 0 && (var_r30->unk_22 & temp_r22) != 0 && var_r30->unk_06 == j) {
+                                if ((var_r30->attr & 9) == 0 && (var_r30->camera & temp_r22) != 0 && var_r30->layer == j) {
-                                    if (((var_r30->unk_50 & 0x800) == 0 && (var_r30->unk_50 & 0x100) == 0) || ((var_r30->unk_50 & 0x100) != 0 && (var_r30->unk_00 & 1) != 0)) {
+                                    if (((var_r30->attr & 0x800) == 0 && (var_r30->attr & 0x100) == 0) || ((var_r30->attr & 0x100) != 0 && (var_r30->unk_00 & 1) != 0)) {
                                         var_r25 = 0;
-                                        var_r30->unk_54 &= 0xBFFFFFFF;
+                                        var_r30->motion_attr &= 0xBFFFFFFF;
                                         if (var_r30->unk_08 != -1) {
                                             Hu3DMotionExec(i, var_r30->unk_08, var_r30->unk_64, 0);
                                         }
@@ -219,7 +198,7 @@ void Hu3DExec(void) {
                                         if (var_r30->unk_0A != -1) {
                                             Hu3DMotionExec(i, var_r30->unk_0A, var_r30->unk_74, 1);
                                         }
-                                        if ((var_r30->unk_50 & 0x400) != 0) {
+                                        if ((var_r30->attr & 0x400) != 0) {
                                             ClusterMotionExec(var_r30);
                                             var_r25 = 1;
                                         }
@@ -231,13 +210,13 @@ void Hu3DExec(void) {
                                             }
                                             var_r25 = 1;
                                         }
-                                        if ((var_r30->unk_50 & 0x90) == 0 && (var_r30->unk_54 & 0x40000002) == 0) {
+                                        if ((var_r30->attr & 0x90) == 0 && (var_r30->motion_attr & 0x40000002) == 0) {
                                             var_r25 = 1;
                                             InitVtxParm(var_r30->hsfData);
                                             if (var_r30->unk_0E != -1) {
                                                 ShapeProc(var_r30->hsfData);
                                             }
-                                            if ((var_r30->unk_50 & 0x400) != 0) {
+                                            if ((var_r30->attr & 0x400) != 0) {
                                                 ClusterProc(var_r30);
                                             }
                                             if (var_r30->hsfData->cenvCnt != 0) {
@@ -248,19 +227,19 @@ void Hu3DExec(void) {
                                         if (var_r25 != 0) {
                                             GXInvalidateVtxCache();
                                         }
-                                        var_r30->unk_50 |= 0x800;
+                                        var_r30->attr |= 0x800;
                                     }
-                                    if (var_r24 != 0 && (var_r30->unk_50 & 0x10) != 0) {
+                                    if (var_r24 != 0 && (var_r30->attr & 0x10) != 0) {
                                         GXWaitDrawDone();
                                         var_r24 = 0;
                                     }
-                                    if ((var_r30->unk_50 & 0x8000) == 0 && (lbl_801D4AB4 != var_r30->unk_E4 || lbl_801D4AB4 != var_r30->unk_E8 || lbl_801D4AB4 != var_r30->unk_EC)) {
+                                    if ((var_r30->attr & 0x8000) == 0 && (lbl_801D4AB4 != var_r30->scale.x || lbl_801D4AB4 != var_r30->scale.y || lbl_801D4AB4 != var_r30->scale.z)) {
-                                        mtxRot(sp40, var_r30->unk_D8, var_r30->unk_DC, var_r30->unk_E0);
+                                        mtxRot(sp40, var_r30->rot.x, var_r30->rot.y, var_r30->rot.z);
-                                        mtxScaleCat(sp40, var_r30->unk_E4, var_r30->unk_E8, var_r30->unk_EC);
+                                        mtxScaleCat(sp40, var_r30->scale.x, var_r30->scale.y, var_r30->scale.z);
-                                        mtxTransCat(sp40, var_r30->unk_CC, var_r30->unk_D0, var_r30->unk_D4);
+                                        mtxTransCat(sp40, var_r30->pos.x, var_r30->pos.y, var_r30->pos.z);
                                         PSMTXConcat(Hu3DCameraMtx, sp40, sp10);
                                         PSMTXConcat(sp10, var_r30->unk_F0, sp10);
-                                        Hu3DDraw(var_r30, sp10[0], &var_r30->unk_E4);
+                                        Hu3DDraw(var_r30, sp10[0], &var_r30->scale.x);
                                     }
                                     var_r30->unk_00++;
                                     var_r23++;
@@ -280,7 +259,7 @@ void Hu3DExec(void) {
     HuSprExec(0);
     var_r30 = Hu3DData;
     for (i = 0; i < 0x200; i++, var_r30++) {
-        if (var_r30->hsfData != 0 && (var_r30->unk_08 != -1 || (var_r30->unk_50 & 0x400) != 0 || var_r30->unk_0E != -1) && (Hu3DPauseF == 0 || (var_r30->unk_50 & 0x200000) != 0)) {
+        if (var_r30->hsfData != 0 && (var_r30->unk_08 != -1 || (var_r30->attr & 0x400) != 0 || var_r30->unk_0E != -1) && (Hu3DPauseF == 0 || (var_r30->attr & 0x200000) != 0)) {
             Hu3DMotionNext(i);
         }
     }
@@ -289,6 +268,534 @@ 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->attr = 0;
+    var_r31->motion_attr = 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->pos.x = var_r31->pos.y = var_r31->pos.z = lbl_801D4AB4;
+    var_r31->rot.x = var_r31->rot.y = var_r31->rot.z = lbl_801D4AB4;
+    var_r31->scale.x = var_r31->scale.y = var_r31->scale.z = lbl_801D4AB8;
+    var_r31->camera = -1;
+    var_r31->layer = 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->attr = temp_r30->attr;
+    temp_r30->attr |= 0x100000;
+    var_r31->motion_attr = temp_r30->motion_attr;
+    var_r31->pos.x = var_r31->pos.y = var_r31->pos.z = lbl_801D4AB4;
+    var_r31->rot.x = var_r31->rot.y = var_r31->rot.z = lbl_801D4AB4;
+    var_r31->scale.x = var_r31->scale.y = var_r31->scale.z = 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->attr |= 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->camera = -1;
+    var_r31->layer = 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->attr = 0x10;
+    var_r31->motion_attr = 0;
+    var_r31->pos.x = var_r31->pos.y = var_r31->pos.z = lbl_801D4AB4;
+    var_r31->rot.x = var_r31->rot.y = var_r31->rot.z = lbl_801D4AB4;
+    var_r31->scale.x = var_r31->scale.y = var_r31->scale.z = 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->camera = -1;
+    var_r31->layer = 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->attr & 4) != 0) {
+            Hu3DShadowCamBit -= 1;
+        }
+        layerNum[temp_r31->layer] -= 1;
+
+        if ((temp_r31->attr & 0x10) != 0) {
+            HuMemDirectFreeNum(HEAP_DATA, (u32) temp_r31->unk_48);
+            if ((temp_r31->attr & 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->attr & 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 Hu3DModelAllKill(void) {
+    ModelData* var_r30;
+    s16 i;
+
+    modelKillAllF = 1;
+    var_r30 = Hu3DData;
+    
+    for (i = 0; i < 0x200; i++, var_r30++) {
+        if (var_r30->hsfData != 0) {
+            Hu3DModelKill(i);
+        }
+    }
+    modelKillAllF = 0;
+    
+    for (i = 0; i < 8; i++) {
+        layerNum[i] = 0;
+        layerHook[i] = NULL;
+    }
+    Hu3DParManAllKill();
+    HuMemDCFlush(HEAP_DATA);
+}
+
+void Hu3DModelPosSet(s16 index, f32 x, f32 y, f32 z) {
+    ModelData* temp_r31;
+
+    temp_r31 = &Hu3DData[index];
+    temp_r31->pos.x = x;
+    temp_r31->pos.y = y;
+    temp_r31->pos.z = z;
+}
+
+void Hu3DModelPosSetV(s16 arg0, Vec arg1) {
+    ModelData* temp_r31;
+
+    temp_r31 = &Hu3DData[arg0];
+    temp_r31->pos = arg1;
+}
+
+void Hu3DModelRotSet(s16 index, f32 x, f32 y, f32 z) {
+    ModelData* temp_r31;
+
+    temp_r31 = &Hu3DData[index];
+    temp_r31->rot.x = x;
+    temp_r31->rot.y = y;
+    temp_r31->rot.z = z;
+}
+
+void Hu3DModelRotSetV(s16 arg0, Vec arg1) {
+    ModelData* temp_r31;
+
+    temp_r31 = &Hu3DData[arg0];
+    temp_r31->rot = arg1;
+}
+
+void Hu3DModelScaleSet(s16 index, f32 x, f32 y, f32 z) {
+    ModelData* temp_r31;
+
+    temp_r31 = &Hu3DData[index];
+    temp_r31->scale.x = x;
+    temp_r31->scale.y = y;
+    temp_r31->scale.z = z;
+}
+
+void Hu3DModelScaleSetV(s16 arg0, Vec arg1) {
+    ModelData* temp_r31;
+
+    temp_r31 = &Hu3DData[arg0];
+    temp_r31->scale = arg1;
+}
+
+void Hu3DModelAttrSet(s16 arg0, u32 arg1) {
+    ModelData* temp_r31;
+
+    temp_r31 = &Hu3DData[arg0];
+    if ((arg1 & (1 << 30)) != 0) {
+        temp_r31->motion_attr |= arg1 & 0xBFFFFFFF;
+    } else {
+        temp_r31->attr |= arg1;
+    }
+}
+
+void Hu3DModelAttrReset(s16 arg0, u32 arg1) {
+    ModelData* temp_r31;
+
+    temp_r31 = &Hu3DData[arg0];
+    if ((arg1 & (1 << 30)) != 0) {
+        temp_r31->motion_attr &= ~arg1;
+    } else {
+        temp_r31->attr &= ~arg1;
+    }
+}
+
+u32 Hu3DModelAttrGet(s16 arg0) {
+    ModelData *copy = &Hu3DData[arg0];
+    return copy->attr;
+}
+
+u32 Hu3DModelMotionAttrGet(s16 arg0) {
+    ModelData *copy = &Hu3DData[arg0];
+    return copy->motion_attr;
+}
+
+void Hu3DModelClusterAttrSet(s16 arg0, s16 arg1, s32 arg2) {
+    ModelData* temp_r31;
+    s32 temp_r6;
+
+    temp_r31 = &Hu3DData[arg0];
+    temp_r31->cluster_attr[arg1] |= arg2;
+}
+
+void Hu3DModelClusterAttrReset(s16 arg0, s16 arg1, s32 arg2) {
+    ModelData* temp_r31;
+
+    temp_r31 = &Hu3DData[arg0];
+    temp_r31->cluster_attr[arg1] &= ~arg2;
+}
+
+void Hu3DModelCameraSet(s16 arg0, u16 arg1) {
+    ModelData* copy = &Hu3DData[arg0];
+    copy->camera = arg1;
+}
+
+void Hu3DModelLayerSet(s16 arg0, s16 arg1) {
+    ModelData* temp_r31;
+
+    temp_r31 = &Hu3DData[arg0];
+    layerNum[temp_r31->layer] -= 1;
+    temp_r31->layer = arg1;
+    layerNum[arg1] += 1;
+}
+
+HsfObject* Hu3DModelObjPtrGet(s16 arg0, s32 arg1) {
+    char name[0x100];
+    s32 spC;
+    s16 sp8;
+    HsfData* temp_r31;
+    s16 var_r30;
+    HsfObject* var_r29;
+    HsfObject* var_r28;
+    u32 var_r4;
+
+    temp_r31 = Hu3DData[arg0].hsfData;
+    var_r29 = temp_r31->object;
+    strcpy(&name, MakeObjectName(arg1));
+    
+    for (var_r30 = 0; var_r30 < temp_r31->objectCnt; var_r29++, var_r30++) {
+        var_r28 = var_r29;
+        if (strcmp(&name, var_r28->name) == 0) {
+            return var_r29;
+        }
+    }
+    if (var_r30 == temp_r31->objectCnt) {
+        OSReport("Error: OBJPtr Error!\n");
+    }
+    return NULL;
+}
+
+static inline void inlineFunc(HsfObject* var_r26) {
+    HsfConstData* temp_r25;
+    HsfObject* copy = var_r26;
+    if (copy->type == 2U) {
+        temp_r25 = copy->constData;
+        temp_r25->flags |= 1;
+    } 
+}
+
+void Hu3DModelTPLvlSet(s16 arg0, f32 arg8) {
+    HsfMaterial* var_r31;
+    HsfData* temp_r30;
+    s16 i;
+    ModelData* temp_r28;
+    HsfObject* var_r27;
+    HsfObject* var_r26;
+    HsfConstData* temp_r25;
+
+    temp_r28 = &Hu3DData[arg0];
+    temp_r30 = temp_r28->hsfData;
+    var_r31 = temp_r30->material;
+    for (i = 0; i < temp_r30->materialCnt; i++, var_r31++) {
+        var_r31->invAlpha = lbl_801D4AB8 - arg8;
+        if (lbl_801D4AB8 != arg8) {
+            var_r31->pass = (var_r31->pass & 0xF0) | 1;
+        } else {
+            var_r31->pass &= 0xF0;
+        }
+    }
+    var_r26 = temp_r30->object;
+    for (i = 0; i < temp_r30->objectCnt; var_r26++, i++) {
+        inlineFunc(var_r26);
+    }
+    temp_r28->attr |= 0x40000;
+}
+
+// ...
 
 void Hu3DShadowSizeSet(u16 arg0) {
     Hu3DShadowData.unk_02 = arg0;
@@ -334,7 +841,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;
@@ -343,7 +850,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()