Fixed many bugs

extern/aurora

@@ -1 +1 @@
-Subproject commit 357ecba0ae00246332447823fddd83b8da89357f
+Subproject commit cd349a9d85600c01b54c430afa9a1f794695d048

include/dolphin/gx/GXDispList.h

@@ -7,8 +7,15 @@
 extern "C" {
 #endif
 
+#ifdef AURORA
+#define GXCALLDISPLAYLISTLE GXCallDisplayListLE
+#else
+#define GXCALLDISPLAYLISTLE GXCallDisplayList
+#endif
+
 void GXBeginDisplayList(void* list, u32 size);
 u32 GXEndDisplayList(void);
+void GXCallDisplayListLE(const void* list, u32 nbytes);
 void GXCallDisplayList(const void* list, u32 nbytes);
 
 #ifdef __cplusplus

src/REL/m440Dll/main.c

@@ -1901,7 +1901,7 @@ void fn_1_806C(ModelData *arg0, Mtx arg1)
         temp_r29 = &temp_r31->unk2C[temp_r31->unk28->unk38[0]];
         fn_1_7D60(temp_r29->unk80, temp_r29, 0);
         lbl_1_bss_2C = 1;
-        HuSprTexLoad(*hiliteAnim, 0, lbl_1_bss_2C, GX_CLAMP, GX_CLAMP, GX_LINEAR);
+        HuSprTexLoad(hiliteAnim[0], 0, lbl_1_bss_2C, GX_CLAMP, GX_CLAMP, GX_LINEAR);
         fn_1_8470(temp_r31->unk28, temp_r29);
     }
     GXSetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE);

src/game/EnvelopeExec.c

@@ -126,10 +126,6 @@ static void SetEnvelopMtx(HsfObject *arg0, HsfObject *arg1, Mtx arg2) {
 }
 
 void EnvelopeProc(HsfData *arg0) {
-#ifdef TARGET_PC
-    // TODO PC still buggy
-    return;
-#endif
     HsfMatrix *temp_r31;
     HsfObject *temp_r29;
     Mtx sp8;

src/game/hsfanim.c

@@ -489,29 +489,6 @@ void Hu3DTexScrollPauseDisableSet(s16 arg0, s32 arg1) {
     }
 }
 
-#ifdef TARGET_PC
-static void Hu3DParticleCallDisplayList(ParticleData *particle)
-{
-    s32 i;
-    GXBegin(GX_QUADS, GX_VTXFMT0, particle->unk_30 * 4);
-    for (i = 0; i < particle->unk_30; i++) {
-        GXPosition1x16(i*4);
-        GXColor1x16(i);
-        GXTexCoord1x16(0);
-        GXPosition1x16((i*4)+1);
-        GXColor1x16(i);
-        GXTexCoord1x16(1);
-        GXPosition1x16((i*4)+2);
-        GXColor1x16(i);
-        GXTexCoord1x16(2);
-        GXPosition1x16((i*4)+3);
-        GXColor1x16(i);
-        GXTexCoord1x16(3);
-    }
-    GXEnd();
-}
-#endif
-
 s16 Hu3DParticleCreate(AnimData *arg0, s16 arg1) {
     ModelData *temp_r28;
     ParticleData *temp_r31;
@@ -553,7 +530,6 @@ s16 Hu3DParticleCreate(AnimData *arg0, s16 arg1) {
     for (i = 0; i < arg1 * 4; i++, var_r27++) {
         var_r27->x = var_r27->y = var_r27->z = 0.0f;
     }
-#ifndef TARGET_PC
     temp_r24 = HuMemDirectMallocNum(HEAP_DATA, arg1 * 0x60 + 0x80, temp_r28->unk_48);
     temp_r31->unk_50 = temp_r24;
     DCInvalidateRange(temp_r24, arg1 * 0x60 + 0x80);
@@ -574,7 +550,6 @@ s16 Hu3DParticleCreate(AnimData *arg0, s16 arg1) {
         GXTexCoord1x16(3);
     }
     temp_r31->unk_40 = GXEndDisplayList();
-#endif
     return temp_r25;
 }
 
@@ -861,11 +836,7 @@ static void particleFunc(ModelData *arg0, Mtx arg1) {
         GXSetVtxDesc(GX_VA_TEX0, GX_INDEX16);
         GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0);
         GXSETARRAY(GX_VA_TEX0, baseST, sizeof(baseST), 8);
-#ifdef TARGET_PC
-        Hu3DParticleCallDisplayList(temp_r31);
-#else
         GXCallDisplayList(temp_r31->unk_50, temp_r31->unk_40);
-#endif
     }
     if (shadowModelDrawF == 0) {
         if (!(temp_r31->unk_2D & 2) && Hu3DPauseF == 0) {

src/game/hsfdraw.c

@@ -29,7 +29,6 @@ static void objReplica(ModelData *arg0, HsfObject *arg1);
 static void ObjDraw(HsfDrawObject *arg0);
 static void MDObjCall(HsfData *arg0, HsfObject *arg1);
 static void MDObjMesh(HsfData *arg0, HsfObject *arg1);
-static void FaceDrawCallDisplayList(HsfObject *arg0, HsfFace *arg1);
 static void MDFaceDraw(HsfObject *arg0, HsfFace *arg1);
 static s32 MakeCalcNBT(HsfObject *arg0, HsfFace *arg1, s16 arg2, s16 arg3);
 static s32 MakeNBT(HsfObject *arg0, HsfFace *arg1, s16 arg2, s16 arg3);
@@ -91,7 +90,6 @@ static u16 *faceNumBuf;
 static s32 DLTotalNum;
 static u32 totalSize;
 static uintptr_t mallocNo;
-static uintptr_t mallocNo;
 static s32 curModelID;
 static s16 polySize;
 static s32 PGFinishF;
@@ -749,20 +747,12 @@ static void FaceDraw(HsfDrawObject *arg0, HsfFace *arg1)
             }
             SetTevStageTex(arg0, temp_r30);
         }
-#ifdef TARGET_PC
-        FaceDrawCallDisplayList(arg0->object, arg1);
-#else
         sp28 = (u8 *)DLBufStartP + DrawData[drawCnt].dlOfs;
-        GXCallDisplayList(sp28, DrawData[drawCnt].dlSize);
+        GXCALLDISPLAYLISTLE(sp28, DrawData[drawCnt].dlSize);
-#endif
     }
     else {
-#ifdef TARGET_PC
-        FaceDrawCallDisplayList(arg0->object, arg1);
-#else
         sp28 = (u8 *)DLBufStartP + DrawData[drawCnt].dlOfs;
-        GXCallDisplayList(sp28, DrawData[drawCnt].dlSize);
+        GXCALLDISPLAYLISTLE(sp28, DrawData[drawCnt].dlSize);
-#endif
     }
     drawCnt++;
 }
@@ -1783,7 +1773,7 @@ static void FaceDrawShadow(HsfDrawObject *arg0, HsfFace *arg1)
                 else {
                     GXSetVtxDesc(GX_VA_NRM, GX_INDEX16);
                     if (temp_r28->hsfData->cenvCnt == 0) {
-                        GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_NRM, GX_NRM_XYZ, GX_RGB8, 0);
+                        GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_NRM, GX_NRM_XYZ, GX_S8, 0);
                         GXSETARRAY(GX_VA_NRM, temp_r31->data.normal->data, temp_r31->data.vertex->count * 3, 3);
                     }
                     else {
@@ -1811,24 +1801,16 @@ static void FaceDrawShadow(HsfDrawObject *arg0, HsfFace *arg1)
         }
         GXSetChanCtrl(GX_COLOR0A0, GX_FALSE, GX_SRC_REG, GX_SRC_VTX, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE);
         GXSetChanCtrl(GX_COLOR1A1, GX_FALSE, GX_SRC_REG, GX_SRC_VTX, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE);
-#ifdef TARGET_PC
-        FaceDrawCallDisplayList(arg0->object, arg1);
-#else
         var_r26 = (u8 *)DLBufStartP + DrawData[drawCnt].dlOfs;
-        GXCallDisplayList(var_r26, DrawData[drawCnt].dlSize);
+        // GXCALLDISPLAYLISTLE(var_r26, DrawData[drawCnt].dlSize);
-#endif
     }
     else {
         if (!(temp_r27->flags & 0x400)) {
             drawCnt++;
             return;
         }
-#ifdef TARGET_PC
-        FaceDrawCallDisplayList(arg0->object, arg1);
-#else
         var_r26 = (u8 *)DLBufStartP + DrawData[drawCnt].dlOfs;
-        GXCallDisplayList(var_r26, DrawData[drawCnt].dlSize);
+        // GXCALLDISPLAYLISTLE(var_r26, DrawData[drawCnt].dlSize);
-#endif
     }
     drawCnt++;
 }
@@ -2623,205 +2605,6 @@ HsfConstData *ObjConstantMake(HsfObject *arg0, u32 arg1)
     return temp_r3;
 }
 
-#ifdef TARGET_PC
-static void FaceDrawCallDisplayList(HsfObject *arg0, HsfFace *arg1)
-{
-    s32 temp_r28;
-    s16 var_r26 = -1;
-    s16 var_r27;
-    s32 var_r25;
-    s16 *var_r24;
-    HsfMaterial *temp_r30 = &arg0->data.material[arg1->mat & 0xFFF];
-    if (temp_r30->numAttrs == 0) {
-        var_r25 = 0;
-    }
-    else {
-        var_r25 = 1;
-        for (var_r27 = 0; var_r27 < temp_r30->numAttrs; var_r27++) {
-            if (arg0->data.attribute[temp_r30->attrs[var_r27]].unk14 != 0.0) {
-                var_r26 = var_r27;
-            }
-        }
-    }
-    switch (arg1->type & 7) {
-        case 0:
-        case 1:
-            break;
-        case 2:
-            GXBegin(GX_TRIANGLES, GX_VTXFMT0, DrawData[drawCnt].polyCnt * 3);
-            for (var_r27 = 0; var_r27 < DrawData[drawCnt].polyCnt; var_r27++, arg1++) {
-                GXPosition1x16(arg1->indices[0][0]);
-                if (var_r26 == -1) {
-                    GXNormal1x16(arg1->indices[0][1]);
-                }
-                else {
-                    MakeCalcNBT(arg0, arg1, 0, 1);
-                }
-                if (temp_r30->vtxMode == 5) {
-                    temp_r28 = arg1->indices[0][2];
-                    GXColor1x16(temp_r28);
-                }
-                if (var_r25 != 0) {
-                    GXTexCoord1x16(arg1->indices[0][3]);
-                }
-                GXPosition1x16(arg1->indices[2][0]);
-                if (var_r26 == -1) {
-                    GXNormal1x16(arg1->indices[2][1]);
-                }
-                else {
-                    MakeNBT(arg0, arg1, 2, 0);
-                }
-                if (temp_r30->vtxMode == 5) {
-                    temp_r28 = arg1->indices[2][2];
-                    GXColor1x16(temp_r28);
-                }
-                if (var_r25 != 0) {
-                    GXTexCoord1x16(arg1->indices[2][3]);
-                }
-                GXPosition1x16(arg1->indices[1][0]);
-                if (var_r26 == -1) {
-                    GXNormal1x16(arg1->indices[1][1]);
-                }
-                else {
-                    MakeNBT(arg0, arg1, 1, 2);
-                }
-                if (temp_r30->vtxMode == 5) {
-                    temp_r28 = arg1->indices[1][2];
-                    GXColor1x16(temp_r28);
-                }
-                if (var_r25 != 0) {
-                    GXTexCoord1x16(arg1->indices[1][3]);
-                }
-            }
-            break;
-        case 3:
-            GXBegin(GX_QUADS, GX_VTXFMT0, DrawData[drawCnt].polyCnt * 4);
-            for (var_r27 = 0; var_r27 < DrawData[drawCnt].polyCnt; var_r27++, arg1++) {
-                GXPosition1x16(arg1->indices[0][0]);
-                if (var_r26 == -1) {
-                    GXNormal1x16(arg1->indices[0][1]);
-                }
-                else {
-                    MakeCalcNBT(arg0, arg1, 0, 1);
-                }
-                if (temp_r30->vtxMode == 5) {
-                    temp_r28 = arg1->indices[0][2];
-                    GXColor1x16(temp_r28);
-                }
-                if (var_r25 != 0) {
-                    GXTexCoord1x16(arg1->indices[0][3]);
-                }
-                GXPosition1x16(arg1->indices[2][0]);
-                if (var_r26 == -1) {
-                    GXNormal1x16(arg1->indices[2][1]);
-                }
-                else {
-                    MakeNBT(arg0, arg1, 2, 0);
-                }
-                if (temp_r30->vtxMode == 5) {
-                    temp_r28 = arg1->indices[2][2];
-                    GXColor1x16(temp_r28);
-                }
-                if (var_r25 != 0) {
-                    GXTexCoord1x16(arg1->indices[2][3]);
-                }
-                GXPosition1x16(arg1->indices[3][0]);
-                if (var_r26 == -1) {
-                    GXNormal1x16(arg1->indices[3][1]);
-                }
-                else {
-                    MakeNBT(arg0, arg1, 3, 2);
-                }
-                if (temp_r30->vtxMode == 5) {
-                    temp_r28 = arg1->indices[3][2];
-                    GXColor1x16(temp_r28);
-                }
-                if (var_r25 != 0) {
-                    GXTexCoord1x16(arg1->indices[3][3]);
-                }
-                GXPosition1x16(arg1->indices[1][0]);
-                if (var_r26 == -1) {
-                    GXNormal1x16(arg1->indices[1][1]);
-                }
-                else {
-                    MakeNBT(arg0, arg1, 1, 3);
-                }
-                if (temp_r30->vtxMode == 5) {
-                    temp_r28 = arg1->indices[1][2];
-                    GXColor1x16(temp_r28);
-                }
-                if (var_r25 != 0) {
-                    GXTexCoord1x16(arg1->indices[1][3]);
-                }
-            }
-            break;
-        case 4:
-            // TODO PC fix size
-            GXBegin(GX_TRIANGLESTRIP, GX_VTXFMT0, DrawData[drawCnt].polyCnt);
-            GXPosition1x16(arg1->indices[0][0]);
-            if (var_r26 == -1) {
-                GXNormal1x16(arg1->indices[0][1]);
-            }
-            else {
-                MakeCalcNBT(arg0, arg1, 0, 1);
-            }
-            if (temp_r30->vtxMode == 5) {
-                temp_r28 = arg1->indices[0][2];
-                GXColor1x16(temp_r28);
-            }
-            if (var_r25 != 0) {
-                GXTexCoord1x16(arg1->indices[0][3]);
-            }
-            GXPosition1x16(arg1->indices[2][0]);
-            if (var_r26 == -1) {
-                GXNormal1x16(arg1->indices[2][1]);
-            }
-            else {
-                MakeNBT(arg0, arg1, 2, 0);
-            }
-            if (temp_r30->vtxMode == 5) {
-                temp_r28 = arg1->indices[2][2];
-                GXColor1x16(temp_r28);
-            }
-            if (var_r25 != 0) {
-                GXTexCoord1x16(arg1->indices[2][3]);
-            }
-            GXPosition1x16(arg1->indices[1][0]);
-            if (var_r26 == -1) {
-                GXNormal1x16(arg1->indices[1][1]);
-            }
-            else {
-                MakeNBT(arg0, arg1, 1, 2);
-            }
-            if (temp_r30->vtxMode == 5) {
-                temp_r28 = arg1->indices[1][2];
-                GXColor1x16(temp_r28);
-            }
-            if (var_r25 != 0) {
-                GXTexCoord1x16(arg1->indices[1][3]);
-            }
-            var_r24 = arg1->strip.data;
-            for (var_r27 = 0; var_r27 < arg1->strip.count; var_r27++, var_r24 += 4) {
-                GXPosition1x16(var_r24[0]);
-                if (var_r26 == -1) {
-                    GXNormal1x16(var_r24[1]);
-                }
-                else {
-                    MakeCalcNBT(arg0, arg1, 0, 1);
-                }
-                if (temp_r30->vtxMode == 5) {
-                    temp_r28 = var_r24[2];
-                    GXColor1x16(temp_r28);
-                }
-                if (var_r25 != 0) {
-                    GXTexCoord1x16(var_r24[3]);
-                }
-            }
-            break;
-    }
-}
-#endif
-
 static void MDFaceDraw(HsfObject *arg0, HsfFace *arg1)
 {
     HsfMaterial *temp_r30;
@@ -2838,7 +2621,7 @@ static void MDFaceDraw(HsfObject *arg0, HsfFace *arg1)
     if (temp_r30 != materialBak || polyTypeBak != (arg1->type & 7) || (arg1->type & 7) == 4) {
         polyTypeBak = arg1->type & 7;
         materialBak = temp_r30;
-        DrawData[drawCnt].dlOfs = (u32)DLBufP - (u32)DLBufStartP;
+        DrawData[drawCnt].dlOfs = (uintptr_t)DLBufP - (uintptr_t)DLBufStartP;
         GXBeginDisplayList(DLBufP, 0x20000);
         GXResetWriteGatherPipe();
         if (temp_r30->numAttrs == 0) {
@@ -2879,96 +2662,6 @@ static void MDFaceDraw(HsfObject *arg0, HsfFace *arg1)
             Hu3DObjInfoP->flags |= 0x10000;
         }
         faceCnt = 0;
-#ifdef TARGET_PC
-        // set flags and calculate faceCnt are left here
-        switch (arg1->type & 7) {
-            case 0:
-            case 1:
-                break;
-            case 2:
-                for (var_r27 = 0; var_r27 < faceNumBuf[drawCnt] / 3; var_r27++, arg1++) {
-                    if (temp_r30->vtxMode == 5) {
-                        temp_r28 = arg1->indices[0][2];
-                        if (((GXColor *)arg0->data.color->data)[temp_r28].a != 0xFF) {
-                            Hu3DObjInfoP->flags |= 0x4001;
-                        }
-                    }
-                    if (temp_r30->vtxMode == 5) {
-                        temp_r28 = arg1->indices[2][2];
-                        if (((GXColor *)arg0->data.color->data)[temp_r28].a != 0xFF) {
-                            Hu3DObjInfoP->flags |= 0x4001;
-                        }
-                    }
-                    if (temp_r30->vtxMode == 5) {
-                        temp_r28 = arg1->indices[1][2];
-                        if (((GXColor *)arg0->data.color->data)[temp_r28].a != 0xFF) {
-                            Hu3DObjInfoP->flags |= 0x4001;
-                        }
-                    }
-                }
-                faceCnt = faceNumBuf[drawCnt] / 3;
-                break;
-            case 3:
-                for (var_r27 = 0; var_r27 < faceNumBuf[drawCnt] / 4; var_r27++, arg1++) {
-                    if (temp_r30->vtxMode == 5) {
-                        temp_r28 = arg1->indices[0][2];
-                        if (((GXColor *)arg0->data.color->data)[temp_r28].a != 0xFF) {
-                            Hu3DObjInfoP->flags |= 0x4001;
-                        }
-                    }
-                    if (temp_r30->vtxMode == 5) {
-                        temp_r28 = arg1->indices[2][2];
-                        if (((GXColor *)arg0->data.color->data)[temp_r28].a != 0xFF) {
-                            Hu3DObjInfoP->flags |= 0x4001;
-                        }
-                    }
-                    if (temp_r30->vtxMode == 5) {
-                        temp_r28 = arg1->indices[3][2];
-                        if (((GXColor *)arg0->data.color->data)[temp_r28].a != 0xFF) {
-                            Hu3DObjInfoP->flags |= 0x4001;
-                        }
-                    }
-                    if (temp_r30->vtxMode == 5) {
-                        temp_r28 = arg1->indices[1][2];
-                        if (((GXColor *)arg0->data.color->data)[temp_r28].a != 0xFF) {
-                            Hu3DObjInfoP->flags |= 0x4001;
-                        }
-                    }
-                }
-                faceCnt = faceNumBuf[drawCnt] / 4;
-                break;
-            case 4:
-                if (temp_r30->vtxMode == 5) {
-                    temp_r28 = arg1->indices[0][2];
-                    if (((GXColor *)arg0->data.color->data)[temp_r28].a != 0xFF) {
-                        Hu3DObjInfoP->flags |= 0x4001;
-                    }
-                }
-                if (temp_r30->vtxMode == 5) {
-                    temp_r28 = arg1->indices[2][2];
-                    if (((GXColor *)arg0->data.color->data)[temp_r28].a != 0xFF) {
-                        Hu3DObjInfoP->flags |= 0x4001;
-                    }
-                }
-                if (temp_r30->vtxMode == 5) {
-                    temp_r28 = arg1->indices[1][2];
-                    if (((GXColor *)arg0->data.color->data)[temp_r28].a != 0xFF) {
-                        Hu3DObjInfoP->flags |= 0x4001;
-                    }
-                }
-                var_r24 = arg1->strip.data;
-                for (var_r27 = 0; var_r27 < arg1->strip.count; var_r27++, var_r24 += 4) {
-                    if (temp_r30->vtxMode == 5) {
-                        temp_r28 = var_r24[2];
-                        if (((GXColor *)arg0->data.color->data)[temp_r28].a != 0xFF) {
-                            Hu3DObjInfoP->flags |= 0x4001;
-                        }
-                    }
-                }
-                faceCnt = arg1->strip.count + 1;
-                break;
-        }
-#else
         switch (arg1->type & 7) {
             case 0:
             case 1:
@@ -3180,7 +2873,6 @@ static void MDFaceDraw(HsfObject *arg0, HsfFace *arg1)
                 faceCnt = arg1->strip.count + 1;
                 break;
         }
-#endif
         temp_r3 = GXEndDisplayList();
         DrawData[drawCnt].dlSize = temp_r3;
         DrawData[drawCnt].polyCnt = faceCnt;

src/game/hsfload.c

@@ -962,6 +962,7 @@ static void CenvLoad(void)
             dual_new = dual_file = cenv_new[i].dualData;
             for(j=0; j<cenv_new[i].dualCount; j++) {
 #ifdef TARGET_PC
+                s32 k;
                 byteswap_hsfcenv_dual(&dual_data_real[j], &dual_new[j]);
 #endif
                 dual_new[j].target1 = dual_file[j].target1;
@@ -969,12 +970,15 @@ static void CenvLoad(void)
                 dual_new[j].weightCnt = dual_file[j].weightCnt;
                 dual_new[j].weight = (HsfCenvDualWeight *)((uintptr_t)weight_base + (uintptr_t)dual_file[j].weight);
 #ifdef TARGET_PC
-                byteswap_hsfcenv_dual_weight(dual_new[j].weight);
+                for (k = 0; k < dual_new[j].weightCnt; k++) {
+                    byteswap_hsfcenv_dual_weight(&dual_new[j].weight[k]);
+                }
 #endif
             }
             multi_new = multi_file = cenv_new[i].multiData;
             for(j=0; j<cenv_new[i].multiCount; j++) {
 #ifdef TARGET_PC
+                s32 k;
                 byteswap_hsfcenv_multi(&multi_data_real[j], &multi_new[j]);
 #endif
                 multi_new[j].weightCnt = multi_file[j].weightCnt;
@@ -984,7 +988,9 @@ static void CenvLoad(void)
                 multi_new[j].normalCnt = multi_file[j].normalCnt;
                 multi_new[j].weight = (HsfCenvMultiWeight *)((uintptr_t)weight_base + (uintptr_t)multi_file[j].weight);
 #ifdef TARGET_PC
-                byteswap_hsfcenv_multi_weight(dual_new[j].weight);
+                for (k = 0; k < multi_new[j].weightCnt; k++) {
+                    byteswap_hsfcenv_multi_weight(&multi_new[j].weight[k]);
+                }
 #endif
             }
             dual_new = dual_file = cenv_new[i].dualData;
@@ -1896,46 +1902,44 @@ static char *GetMotionString(u16 *str_ofs)
 void KillHSF(HsfData *data)
 {
     s32 i, j;
-    // if (data->attributeCnt)
+    if (data->attributeCnt)
-    //     HuMemDirectFree(data->attribute);
+        HuMemDirectFree(data->attribute);
-    // if (data->bitmapCnt)
+    if (data->bitmapCnt)
-    //     HuMemDirectFree(data->bitmap);
+        HuMemDirectFree(data->bitmap);
-    // if (data->skeletonCnt)
+    if (data->skeletonCnt)
-    //     HuMemDirectFree(data->skeleton);
+        HuMemDirectFree(data->skeleton);
-    // if (data->faceCnt) {
+    if (data->faceCnt) {
-    //     for (i = 0; i < data->faceCnt; i++) {
+        for (i = 0; i < data->faceCnt; i++) {
-    //         HuMemDirectFree(data->face[i].data);
+            HuMemDirectFree(data->face[i].data);
-    //     }
+        }
-    //     HuMemDirectFree(data->face);
+        HuMemDirectFree(data->face);
-    // }
+    }
-    // if (data->materialCnt)
+    if (data->materialCnt)
-    //     HuMemDirectFree(data->material);
+        HuMemDirectFree(data->material);
-    // if (data->motionCnt) {
+    if (data->motionCnt) {
-    //     for (i = 0; i < data->motionCnt; i++) {
+        HsfMotion *motion = data->motion;
-    //         HsfMotion *motion = &data->motion[i];
+        for (j = 0; j < motion->numTracks; j++) {
-    //         for (j = 0; j < motion->numTracks; j++) {
+            HsfTrack *track = motion->track;
-    //             // HsfTrack *track = motion->track;
+            if (track->type == HSF_TRACK_ATTRIBUTE && track->curveType == HSF_CURVE_BITMAP) {
-    //             // if (track->type == HSF_TRACK_ATTRIBUTE && track->curveType == HSF_CURVE_BITMAP) {
+                // in this case we needed to allocate space for HsfBitmapKey structs
-    //             //     // in this case we needed to allocate space for HsfBitmapKey structs
+                HuMemDirectFree(track->dataTop);
-    //             //     HuMemDirectFree(track->dataTop);
+            }
-    //             // }
+        }
-    //         }
+        HuMemDirectFree(motion->track);
-    //         // HuMemDirectFree(motion->track);
+        HuMemDirectFree(data->motion);
-    //     }
+    }
-    //     // HuMemDirectFree(data->motion);
+    if (data->normalCnt)
-    // }
+        HuMemDirectFree(data->normal);
-    // if (data->normalCnt)
+    if (data->objectCnt)
-    //     HuMemDirectFree(data->normal);
+        HuMemDirectFree(data->object);
-    // if (data->objectCnt)
+    if (data->matrixCnt)
-    //     HuMemDirectFree(data->object);
+        HuMemDirectFree(data->matrix);
-    // if (data->matrixCnt)
+    if (data->paletteCnt)
-    //     HuMemDirectFree(data->matrix);
+        HuMemDirectFree(data->palette);
-    // if (data->paletteCnt)
+    if (data->stCnt)
-    //     HuMemDirectFree(data->palette);
+        HuMemDirectFree(data->st);
-    // if (data->stCnt)
+    if (data->vertexCnt)
-    //     HuMemDirectFree(data->st);
+        HuMemDirectFree(data->vertex);
-    // if (data->vertexCnt)
-    //     HuMemDirectFree(data->vertex);
     if (data->cenvCnt) {
         for (i = 0; i < data->cenvCnt; i++) {
             HsfCenv *cenv = &data->cenv[i];
@@ -1952,6 +1956,6 @@ void KillHSF(HsfData *data)
         HuMemDirectFree(data->shape);
     if (data->mapAttrCnt)
         HuMemDirectFree(data->mapAttr);
-    // HuMemDirectFree(data->symbol);
+    HuMemDirectFree(data->symbol);
 }
 #endif

src/game/sprman.c

@@ -220,11 +220,12 @@ AnimData *HuSprAnimRead(void *data)
 
     AnimData *anim = data;
 #ifdef TARGET_PC
+    s16 j;
     if (anim->valid == ANIM_DATA_ALLOCATION_VALID) {
         anim->useNum++;
         return anim;
     }
-    anim = HuMemDirectMallocNum(HEAP_DATA, sizeof(AnimData), MEMORY_DEFAULT_NUM);
+    anim = HuMemDirectMalloc(HEAP_DATA, sizeof(AnimData));
     byteswap_animdata(data, anim);
     anim->valid = ANIM_DATA_ALLOCATION_VALID;
 #else
@@ -235,7 +236,7 @@ AnimData *HuSprAnimRead(void *data)
 #endif
     bank = (void *)((uintptr_t)anim->bank+(uintptr_t)data);
 #ifdef TARGET_PC
-    bank = HuMemDirectMallocNum(HEAP_DATA, anim->bankNum * sizeof(AnimBankData), MEMORY_DEFAULT_NUM);
+    bank = HuMemDirectMalloc(HEAP_DATA, anim->bankNum * sizeof(AnimBankData));
     for(i=0; i<anim->bankNum; i++) {
         byteswap_animbankdata(&((AnimBankData32b*)((uintptr_t)anim->bank+(uintptr_t)data))[i], &bank[i]);
     }
@@ -243,7 +244,7 @@ AnimData *HuSprAnimRead(void *data)
     anim->bank = bank;
     pat = (void *)((uintptr_t)anim->pat+(uintptr_t)data);
 #ifdef TARGET_PC
-    pat = HuMemDirectMallocNum(HEAP_DATA, anim->patNum * sizeof(AnimPatData), MEMORY_DEFAULT_NUM);
+    pat = HuMemDirectMalloc(HEAP_DATA, anim->patNum * sizeof(AnimPatData));
     for(i=0; i<anim->patNum; i++) {
         byteswap_animpatdata(&((AnimPatData32b*)((uintptr_t)anim->pat+(uintptr_t)data))[i], &pat[i]);
     }
@@ -251,7 +252,7 @@ AnimData *HuSprAnimRead(void *data)
     anim->pat = pat;
     bmp = (void *)((uintptr_t)anim->bmp+(uintptr_t)data);
 #ifdef TARGET_PC
-    bmp = HuMemDirectMallocNum(HEAP_DATA, anim->bmpNum * sizeof(AnimBmpData), MEMORY_DEFAULT_NUM);
+    bmp = HuMemDirectMalloc(HEAP_DATA, anim->bmpNum * sizeof(AnimBmpData));
     for(i=0; i<anim->bmpNum; i++) {
         byteswap_animbmpdata(&((AnimBmpData32b*)((uintptr_t)anim->bmp+(uintptr_t)data))[i], &bmp[i]);
     }
@@ -266,7 +267,9 @@ AnimData *HuSprAnimRead(void *data)
     for(i=0; i<anim->patNum; i++, pat++) {
         pat->layer = (AnimLayerData *)((uintptr_t)pat->layer+(uintptr_t)data);
 #ifdef TARGET_PC
-        byteswap_animlayerdata(pat->layer);
+        for (j = 0; j < pat->layerNum; j++) {
+            byteswap_animlayerdata(&pat->layer[j]);
+        }
 #endif
     }
     for(i=0; i<anim->bmpNum; i++, bmp++) {

src/port/byteswap.cpp

@@ -570,10 +570,13 @@ template <typename B> void bswap(B &base, HsfCenvMulti32b &obj, HsfCenvMulti &de
     bswap(base, obj.posCnt);
     bswap(base, obj.normal);
     bswap(base, obj.normalCnt);
+    bswap(base, obj.weight);
 
     dest.weightCnt = obj.weightCnt;
     dest.pos = obj.pos;
     dest.posCnt = obj.posCnt;
+    dest.normal = obj.normal;
+    dest.normalCnt = obj.normalCnt;
     dest.weight = reinterpret_cast<HsfCenvMultiWeight *>(static_cast<uintptr_t>(obj.weight));
 }
 
@@ -695,13 +698,13 @@ template <typename B> void bswap(B &base, HsfBitmapKey32b &obj, HsfBitmapKey &de
 
 template <typename B> void bswap(B &base, HsfTrack32b &obj, HsfTrack &dest)
 {
-    bswap(base, obj.type);
+    bswap(base, obj.target);
-    bswap(base, obj.start);
     bswap(base, obj.curveType);
     bswap(base, obj.numKeyframes);
 
     dest.type = obj.type;
     dest.start = obj.start;
+    dest.target = obj.target;
     dest.curveType = obj.curveType;
     dest.numKeyframes = obj.numKeyframes;
 

src/port/stubs.c

@@ -634,12 +634,6 @@ void GXSetTevIndTile(GXTevStageID tev_stage, GXIndTexStageID ind_stage, u16 tile
     // puts("GXSetTevIndTile is a stub");
 }
 
-void GXSetTexCoordScaleManually(GXTexCoordID coord, u8 enable, u16 ss, u16 ts)
-{
-    // TODO
-    // puts("GXSetTexCoordScaleManually is a stub");
-}
-
 void GXResetWriteGatherPipe(void)
 {
     // puts("GXResetWriteGatherPipe is a stub");
@@ -682,11 +676,6 @@ void GXGetViewportv(f32 *vp)
     // TODO
 }
 
-void GXSetZTexture(GXZTexOp op, GXTexFmt fmt, u32 bias)
-{
-    // TODO
-}
-
 // Hudson
 void HuDvdErrDispInit(GXRenderModeObj *rmode, void *xfb1, void *xfb2) { }